1. Interfaces

1.1 Resumen de interfaces

Una interfaz es un conjunto de funciones; también puede considerarse un tipo de datos, y es más abstracta que una clase abstracta.Clase 。

La interfaz solo describe los métodos que debe tener, sin una implementación concreta; la implementación concreta la realiza la clase de implementación de la interfaz (equivalente a una subclase de la interfaz). Esto separa la definición de la funcionalidad de su implementación, optimizando el diseño del programa.

1.2 Formato y uso de las interfaces

1.2.1 Formato de la interfaz

A diferencia de la definición de una clase `class`,classal definir una interfaz, se necesita usarinterfacela palabra clave `interface`.

La definición de una interfaz todavía se encuentra en un archivo `.java`.java; aunque al declararla se usainterfacela palabra clave `interface`, después de compilar aún se genera un.classarchivo `.class`. Esto nos permite considerar la interfaz como un tipo especial de clase que solo contiene declaraciones de funcionalidades.

Formato de definición:
public interface 接口名 {
    抽象方法1;
    抽象方法2;
    抽象方法3;
}

1.2.2 Uso de la interfaz

Todos los métodos en una interfaz son métodos abstractos. No tiene sentido usar `new` directamente sobre una interfaz para invocar métodos, y Java no lo permite.

La relación entre una clase y una interfaz es de implementación, es decir, la clase implementa la interfaz. La acción de implementar es similar a la herencia, solo que la palabra clave es diferente; para implementar se usa `implements`.implements。

Después de que otra clase (clase de implementación) implementa la interfaz, equivale a declarar:Debo tener las funcionalidades de esta interfaz.La clase de implementación aún necesita sobrescribir los métodos para implementar la funcionalidad concreta.

Formato:

class 类 implements 接口 {
    重写接口中方法
}

Después de que una clase implementa una interfaz, hereda los métodos abstractos de la interfaz; en ese momento, la clase debe sobrescribir estos métodos abstractos para completar la lógica concreta.

1.2.3 Código de ejemplo 1

Ejemplo

/** La herencia en Java es única; una subclase solo puede tener una clase padre (un hijo solo puede tener un padre biológico). * Java nos proporciona un mecanismo para manejar la limitación de la herencia única: las interfaces. * * Interfaz: una interfaz es una clase aún más abstracta que una clase abstracta. Todos los métodos en una interfaz son métodos abstractos. La relación entre interfaz y clase es de implementación: `implements`. * `interface` * * Formato: * `interface NombreDeInterfaz {` * * `}` **/ public class InterfaceDemo { public static void main(String[] args) { BillGates gates = new BillGates(); gates.code(); } } class Boss { public void manage() { System.out.println("Empresa de gestión"); } } class Programmer { public void code() { System.out.println("Escribir código"); } } //Bill Gates class BillGates extends Programmer { }

1.3 Características de los miembros en una interfaz

  • 1. En una interfaz se pueden definir variables, pero deben estar modificadas con modificadores fijos: `public static final`. Por lo tanto, las variables en una interfaz también se denominan constantes y su valor no se puede cambiar. Más adelante explicaremos la palabra clave `final`.

  • 2. En una interfaz se pueden definir métodos, y los métodos también tienen modificadores fijos: `public abstract`.

  • 3. No se pueden crear objetos a partir de una interfaz.

  • 4. Solo después de que la subclase sobrescriba todos los métodos abstractos de la interfaz, la subclase puede ser instanciada. De lo contrario, la subclase es una clase abstracta.

1.3.1 Código de ejemplo 2

Ejemplo

/** Características de los miembros de una interfaz: * solo puede tener métodos abstractos * solo puede tener constantes * por defecto, los métodos se modifican con `public` & `abstract` * solo se pueden modificar métodos con `public` & `abstract` * por defecto, las variables miembro se modifican con `public static final` * * Sugerencia: se recomienda agregar manualmente los modificadores predeterminados * * Nota: * una interfaz no puede crear objetos (no puede ser instanciada) * la relación entre clase e interfaz es de implementación; una clase que implementa una interfaz debe implementar todos sus métodos*/ public class InterfaceDemo2 { public static void main(String[] args) { //Animal a = new Animal(); //Animal.num; } } interface Animal { public static final int num = 10; public abstract void eat(); } class Cat implements Animal { public void eat() { } }

1.4 Relación entre interfaces y clases

  • A: Entre clases: relación de herencia. Una clase solo puede heredar directamente de una clase padre, pero admite herencia múltiple.
  • B: Entre clases e interfaces: solo existe relación de implementación; una clase puede implementar múltiples interfaces.
  • C: Entre interfaces: solo existe relación de herencia; una interfaz puede heredar múltiples interfaces.

1.4.1 Código de ejemplo 3

Ejemplo

/** * Clase y clase: relación de herencia, herencia única, herencia multinivel. * Clase e interfaz: relación de implementación, múltiples implementaciones. * Interfaz e interfaz: relación de herencia, herencia múltiple.*/ public class InterfaceDemo3 { public static void main(String[] args) { } } interface InterA extends InterB { public abstract void method(); } interface InterB { public abstract void function(); } interface InterC extends InterA { } class Demo implements InterC { @Override public void method() { // TODO Auto-generated method stub } @Override public void function() { // TODO Auto-generated method stub } }

1.5 La idea de las interfaces

Hemos aprendido la representación en código de las interfaces; ahora vamos a estudiar la idea de las interfaces. A continuación, lo explicaremos con ejemplos de la vida cotidiana.

Ejemplo:Todos sabemos que la computadora tiene muchos puertos, y en estos puertos se pueden conectar los dispositivos correspondientes. ¿Por qué estos dispositivos se pueden conectar? La razón principal es que estos dispositivos, al fabricarse, cumplen con las reglas de uso del puerto; de lo contrario, no podrían insertarse en la interfaz ni mucho menos usarse. La aparición de estos puertos nos permite usar más dispositivos.

La aparición de las interfaces facilita el uso y el mantenimiento posteriores. Por un lado, se usa la interfaz (como la computadora); por otro lado, se implementa la interfaz (los dispositivos que se conectan al puerto). Por ejemplo: el portátil usa esta regla (interfaz) y los periféricos de la computadora implementan esta regla (interfaz).

En el marco de las colecciones se utilizan muchas interfaces:

Collection 接口

    List 接口

       ArrayList 实现类

       LinkedList 实现类

    Set 接口

1.6 Ventajas de las interfaces

  • 1. La relación entre clases e interfaces es de implementación, y es una implementación múltiple; una clase puede implementar múltiples interfaces. Entre clases, la relación es de herencia; en Java, la herencia es única, una clase solo puede tener una clase padre, lo que rompe la limitación de la herencia.
  • 2. Proporciona reglas al exterior (interfaz USB).
  • 3. Reduce el acoplamiento del programa (permite el desarrollo modular: define las reglas, cada persona implementa su propio módulo, mejorando la eficiencia del desarrollo).

1.7 Diferencias entre interfaces y clases abstractas

1. Puntos en común:Extraer continuamente métodos abstractos sin implementación concreta; ambas no pueden ser instanciadas (no se pueden crear objetos).

2. Diferencias

1: Relación con las clases

(1) La clase y la interfaz tienen una relación de implementación, y es una implementación múltiple; una clase puede implementar múltiples interfaces. La clase y la clase abstracta tienen una relación de herencia; en Java, la herencia es única y de múltiples niveles; una clase solo puede heredar de una clase padre, pero puede tener una clase "abuelo".

(2) Diferencia 2: Miembros

a.成员变量
    抽象类可以有成员变量，也可以有常量
    接口只能有常量，默认修饰符public static final

b.成员方法
    抽象类可以有抽象方法，也可以有非抽象方法
    接口只能有抽象方法，默认修饰符 public abstract

c.构造方法
    抽象类有构造方法，为子类提供
    接口没有构造方法

1.8 Caso de atletas

1.8.1 Código de ejemplo 4

Ejemplo

/** Jugadores y entrenadores de baloncesto Jugadores y entrenadores de tenis de mesa Ahora los jugadores y entrenadores de baloncesto van a visitar el extranjero y necesitan aprender inglés. Por favor, basándote en lo que has aprendido, analiza cuáles son clases, cuáles son clases abstractas y cuáles son interfaces.*/ public class InterfaceTest { public static void main(String[] args) { //Crear un objeto de jugador de baloncesto BasketBallPlayer bbp = new BasketBallPlayer(); bbp.name = "Yao Ming"; bbp.age = 35; bbp.gender = "Hombre"; bbp.sleep(); bbp.study(); bbp.speak(); System.out.println("-------------"); //Crear un objeto de entrenador de tenis de mesa PingpangCoach ppc = new PingpangCoach(); ppc.name = "Liu, el Gordo"; ppc.age = 40; ppc.gender = "Hombre"; ppc.sleep(); ppc.teach(); //ppc.speak(); } } class Person { String name;//Nombre int age;//Edad String gender;//Sexo //Constructor sin parámetros public Person() {} //Constructor con parámetros public Person(String name,int age,String gender) { this.name = name; this.age = age; this.gender = gender; } //comer public void eat() { System.out.println("Comer"); } //dormir public void sleep() { System.out.println("Dormir"); } } //Aprender a hablar inglés interface SpeakEnglish { public abstract void speak(); } //Atleta abstract class Player extends Person { //Aprender public abstract void study(); } //Entrenador abstract class Coach extends Person { //Enseñar public abstract void teach(); } //Jugador de baloncesto class BasketBallPlayer extends Player implements SpeakEnglish{ @Override public void study() { System.out.println("Aprender a hacer mates"); } @Override public void speak() { System.out.println("Hablar inglés"); } } //Jugador de tenis de mesa class PingpangPlayer extends Player { @Override public void study() { System.out.println("Aprender a hacer drives"); } } //Entrenador de baloncesto class BasketBallCoach extends Coach implements SpeakEnglish { @Override public void teach() { System.out.println("Enseñar a hacer mates"); } @Override public void speak() { System.out.println("Hablar inglés"); } } //Entrenador de tenis de mesa class PingpangCoach extends Coach { @Override public void teach() { System.out.println("Enseñar a hacer drives"); } }

2. Polimorfismo

2.1 Resumen del polimorfismo

El polimorfismo es la tercera gran característica de la orientación a objetos, después del encapsulamiento y la herencia.

Las cosas reales a menudo presentan múltiples formas. Por ejemplo, un estudiante es un tipo de persona; entonces un compañero concreto, Zhang San, es a la vez estudiante y persona, es decir, presenta dos formas.

Java, como lenguaje orientado a objetos, también puede describir múltiples formas de una cosa. Por ejemplo, la clase `Student` hereda de `Person`; un objeto de `Student` es tanto `Student` como `Person`.

2.2 Definición y formato de uso del polimorfismo

Formato de definición del polimorfismo: en realidad, es que una variable de referencia de la clase padre apunta a un objeto de la subclase.

父类类型  变量名 = new 子类类型();
变量名.方法名();

A: Formato de definición de polimorfismo con clases normales

父类 变量名 = new 子类();

Por ejemplo:

class Fu {}
class Zi extends Fu {}
//类的多态使用
Fu f = new Zi();

B: Formato de definición de polimorfismo con clases abstractas

抽象类 变量名 = new 抽象类子类();

Por ejemplo:

abstract class Fu {
    public abstract void method();
}
class Zi extends Fu {
    public void method(){
        System.out.println(“重写父类抽象方法”);
    }
}
//类的多态使用
Fu fu= new Zi();

C: Formato de definición de polimorfismo con interfaces

接口 变量名 = new 接口实现类();

Por ejemplo:

interface Fu {
    public abstract void method();
}
class Zi implements Fu {
    public void method(){
        System.out.println(“重写接口抽象方法”);
    }
}
//接口的多态使用
Fu fu = new Zi();

2.2.1 Código de caso

Ejemplo

/** Premisas del polimorfismo: * Relación de herencia entre clase padre e hija * Reescritura de métodos * Referencia de clase padre apuntando a un objeto de clase hija * * Enlace dinámico: el método invocado en tiempo de ejecución se determina según su tipo concreto * * * **/ public class PoymorphicDemo { public static void main(String[] args) { /*Cat c = new Cat(); c.eat();*/ //Referencia de clase padre Animal a //apunta = //objeto de subclase new Cat() Animal a = new Cat(); a.eat(); } } class Animal { public void eat() { System.out.println("Comer"); } } class Cat extends Animal { public void eat() { System.out.println("El gato come pescado"); } }

2.3 Características de los miembros polimórficos

A: Variables miembro del polimorfismo

Cuando aparece una variable miembro con el mismo nombre en la clase padre e hija, al invocarla con polimorfismo:

  • En tiempo de compilación: se consulta si la clase a la que pertenece la variable de tipo referencia contiene la variable miembro invocada. Si no la tiene, la compilación falla.
  • En tiempo de ejecución: también se invoca la variable miembro de la clase a la que pertenece la variable de tipo referencia.

Regla sencilla: tanto la compilación como la ejecución se basan en el lado izquierdo del signo igual. Compilación y ejecución miran a la izquierda.

B: Métodos miembro del polimorfismo

  • En tiempo de compilación: se consulta la clase a la que pertenece la variable de referencia. Si la clase no tiene el método invocado, la compilación falla.
  • En tiempo de ejecución: se consulta la clase del objeto al que apunta la variable de referencia y se ejecuta el método miembro de la clase a la que pertenece el objeto.

En resumen: la compilación mira a la izquierda, la ejecución mira a la derecha.

2.3.1 Código de caso seis

Ejemplo

/** * Características de los miembros del polimorfismo: * Variables miembro: en compilación se mira a la izquierda, en ejecución se mira a la izquierda. * Métodos miembro: en compilación se mira a la izquierda, en ejecución se mira a la derecha. * Métodos estáticos: en compilación se mira a la izquierda, en ejecución también se mira a la izquierda. * * * En compilación todo se mira a la izquierda; en ejecución, los métodos miembro se miran a la derecha; los demás (variables miembro y métodos estáticos) se miran a la izquierda. **/ public class PoymorphicDemo2 { public static void main(String[] args) { Dad d = new Kid(); //System.out.println(d.num); //d.method(); d.function();//Usar una variable para invocar un método estático es equivalente a invocarlo con el nombre de la clase correspondiente al tipo de la variable. } } class Dad { int num = 20; public void method() { System.out.println("Soy el método de la clase padre"); } public static void function() { System.out.println("Soy el método estático de la clase padre"); } } class Kid extends Dad { int num = 10; public void method() { System.out.println("Soy el método de la subclase"); } public static void function() { System.out.println("Soy el método estático de la subclase"); } }

2.4 Upcasting y downcasting en el polimorfismo

La transformación en el polimorfismo se divide en dos tipos: upcasting y downcasting.

A: Upcasting: cuando un objeto de subclase se asigna a una referencia de clase padre, se produce upcasting; el polimorfismo en sí es un proceso de upcasting.

Formato de uso:

父类类型  变量名 = new 子类类型();

Por ejemplo:

Person p = new Student();

B: Downcasting: un objeto de subclase que ya ha sufrido upcasting puede usar el formato de conversión de tipos forzada para convertir la referencia de clase padre en una referencia de subclase; este proceso es downcasting. Si se crea directamente un objeto de clase padre, no se puede realizar downcasting.

Formato de uso:

TipoSubclase nombreVariable = (TipoSubclase) variableDeTipoPadre;

Por ejemplo:

Student stu = (Student) p;  // 变量p 实际上指向 Student 对象

Ejemplo

/** * Upcasting y downcasting en el polimorfismo: * * Conversión entre tipos de referencia * Upcasting * De pequeño a grande (subtipo convertido a tipo padre) * Downcasting * De grande a pequeño * Conversión de tipos de datos básicos * Conversión automática de tipos * De pequeño a grande * byte short char --- int --- long --- float --- double * Conversión de tipos forzada * De grande a pequeño * * **/ public class PoymorphicDemo3 { public static void main(String[] args) { Animal2 a = new Dog();//Upcasting //a.eat(); Dog d = (Dog)a;//Downcasting d.swim(); } } class Animal2 { public void eat() { System.out.println("Comer"); } } class Dog extends Animal2 { public void eat() { System.out.println("Roer huesos"); } public void swim() { System.out.println("Nado de perro"); } }

2.5 Ventajas y desventajas del polimorfismo

Ejemplo

/** * Ventajas y desventajas del polimorfismo * Ventajas: puede mejorar la mantenibilidad (garantizada por las premisas del polimorfismo) y mejorar la escalabilidad del código. * Desventajas: no se puede acceder directamente a los miembros específicos de la subclase.*/ public class PoymorphicDemo4 { public static void main(String[] args) { MiFactory factory = new MiFactory(); factory.createPhone(new MiNote()); factory.createPhone(new RedMi()); } } class MiFactory { /*public void createPhone(MiNote mi) { mi.call(); } public void createPhone(RedMi mi) { mi.call(); }*/ public void createPhone(Phone p) { p.call(); } } interface Phone { public void call(); } //Xiaomi Note class MiNote implements Phone{ public void call() { System.out.println("Xiaomi Note hace una llamada"); } } //Redmi class RedMi implements Phone { public void call() { System.out.println("Redmi hace una llamada"); } }

Dirección original: https://www.cnblogs.com/yoke/p/7453864.html