1. En la declaración de la clase, utilice la palabra clave extends para crear una subclase de la clase. Una clase declara que utiliza una o más interfaces a través de la palabra clave implements.
Extender significa heredar una determinada clase. Después de la herencia, puede usar los métodos de la clase principal o puede anular los métodos de la clase principal. Implementos significa implementar múltiples interfaces. Los métodos de interfaz generalmente están vacíos y deben reescribirse antes de poder escribirse. usado.
2. Extends hereda la clase principal. Siempre que la clase no se declare como final o la clase se defina como abstracta, JAVA no admite herencia múltiple, pero se puede implementar mediante interfaces. Se deben usar implementos. La herencia solo puede heredar una clase, pero los implementos pueden implementar múltiples interfaces, simplemente sepárelas con comas.
Copie el código de código de la siguiente manera:
la clase A extiende B implementa C,D,E
Después de estudiar durante mucho tiempo, finalmente entendí la implementación hoy. En realidad, es muy simple. Solo mire los siguientes ejemplos ~~.
Algunos conceptos de interfaces.
<!--[if !supportLineBreakNewLine]-->
Copie el código de código de la siguiente manera:
corredor de cara interna pública
{
IDint = 1;
ejecución vacía ();
}
interfaz Animal extiende Runner
{
respiración vacía();
}
clase Instrumentos para peces Animal
{
ejecución pública vacía()
{
System.out.println("pez nadando");
}
respiradero público vacío()
{
System.out.println("el pescado está burbujeando");
}
}
abstracto LandAnimal implementa Animal
{
respiradero de vacío público ()
{
System.out.println("El animal terrestre respira");
}
}
clase Estudiante extiende Persona implementa Corredor
{
...
ejecución pública vacía()
{
System.out.println("el estudiante está corriendo");
}
...
}
folleto de interfaz
{
mosca vacía ();
}
clase Bird implementa Runner, Flyer
{
ejecución pública vacía()
{
System.out.println("el pájaro corre");
}
mosca del vacío público ()
{
System.out.println("el pájaro está volando");
}
}
clase TestFish
{
principal público estático vacío (argumentos de cadena [])
{
Pez f = nuevo Pez();
int j = 0;
j = Corredor.ID;
j = f.ID;
}
}
Notas sobre la implementación de la interfaz:
a. Implementar una interfaz es implementar todos los métodos de la interfaz (excepto las clases abstractas).
b. Los métodos en la interfaz son abstractos.
c. Varias clases no relacionadas pueden implementar la misma interfaz y una clase puede implementar múltiples interfaces no relacionadas.
==================================================== =========
La diferencia entre extiende e implementa.
extends es heredar la clase principal. Siempre que la clase no se declare como final o la clase se defina como abstracta, JAVA no admite herencia múltiple, pero se puede implementar mediante interfaces. Se deben usar implementos. La herencia solo puede heredar una clase, pero los implementos pueden implementar múltiples interfaces, simplemente sepárelas con comas.
la clase A extiende B implementa C,D,E
Una clase declara que utiliza una o más interfaces a través de la palabra clave implements. En la declaración de clase, cree una subclase de la clase mediante la palabra clave extend.
Copie el código de código de la siguiente manera:
clase nombre de subclase extiende el nombre de la clase principal implementa el nombre de la interfaz
{...
}
==================================================== =========
A a = new B(); Como resultado, a es una instancia de la clase A y solo puede acceder a métodos en A. Entonces, ¿cuál es la diferencia entre A a = new A();?
==================================================== ========
la clase B extiende A
Después de la herencia, generalmente se definen algunos miembros o métodos que no se encuentran en la clase principal.
A a = nuevo B();
Está bien, súbelo.
a es una instancia de un objeto de clase principal y, por lo tanto, no puede acceder a nuevos miembros o métodos definidos por la subclase.
==================================================== ========
Si se define así:
clase A{
ent i;
vacío f(){}
}
la clase B extiende A{
intj;
void f(){}//Reescribir
vacío g(){}
}
Entonces:
B b = nuevo B();
b es una instancia de un objeto de subclase. No solo puede acceder a sus propias propiedades y métodos, sino también a las propiedades y métodos de la clase principal. Cosas como bi, bj, bf(), bg() son todas legales. En este momento se accede a bf() f() en B
A a = nuevo B();
Aunque a usa el constructor de B, se convierte en una instancia del objeto de la clase principal después de la conversión y no puede acceder a las propiedades y métodos de la subclase. ai,af() son legales, pero aj,ag() son ilegales. En este momento, acceder a af () es acceder a f () en B
==================================================== ========
A a = new B(); Esta declaración en realidad tiene tres procesos:
(1) Una una;
Declare a como objeto de clase principal, que es solo una referencia y no se asigna ningún espacio.
(2) B temp = nuevo B();
Una instancia de un objeto de clase B se establece a través del constructor de clase B, es decir, se inicializa
(3) a = (A)temperatura;
Convierta la temperatura del objeto de subclase en un objeto de clase no principal y asígnelo a. Esta es una carga (upcast), que es segura.
Después de los tres procesos anteriores, a se ha convertido completamente en una instancia de la clase A.
Las subclases suelen tener más propiedades y métodos que las clases principales. La carga sólo las descarta, lo cual es seguro, mientras que la degradación a veces las aumenta, lo que suele ser inseguro;
==================================================== =========
af() debe corresponder al método f() de la clase B
Después de llamar al constructor para crear una instancia, se determina la entrada al método correspondiente.
Desde entonces, aunque a se ha subido como clase A, el método anulado f() sigue siendo el método f() de B. Es decir, cada objeto sabe a qué método debe llamar.
A a1 = nuevo B();
A a2 = nuevo C();
Aunque a1 y a2 son objetos de clase A, sus respectivos f() son diferentes. Esta es exactamente la encarnación del polimorfismo mencionado en el primer piso.
Estos problemas se explican muy claramente en "Pensamientos sobre programación Java".
Implements generalmente implementa la interfaz. extends es una clase heredada. Las interfaces generalmente solo tienen declaraciones de métodos pero no definiciones, por lo que tiene sentido que Java señale específicamente la implementación de las interfaces, porque la herencia significa que la clase principal ha implementado métodos, mientras que las interfaces no implementan sus propios métodos, solo declaraciones, es decir. Un encabezado de método no tiene cuerpo de método. Por lo tanto, se puede entender que una interfaz es una subclase que implementa sus declaraciones de métodos en lugar de heredar sus métodos. Pero los métodos de clase generales pueden tener cuerpos de método, por lo que es más razonable llamarlos herencia. Al importar un paquete, se pueden utilizar todas las clases implementadas que no sean interfaces en él. Luego usted decide si implementar la interfaz o no. Si desea usarla, no puede llamar a la interfaz sin implementarla, porque la interfaz es una especificación, una colección de declaraciones de métodos sin un cuerpo de método. Déjame darte un ejemplo: una interfaz se puede comparar con un protocolo. Por ejemplo, si digo que un protocolo es "matar", entonces puedes usar un machete para implementar esta interfaz. En cuanto a cómo matar, el machete se puede implementar. Por supuesto, también puedes usar grab para implementar la interfaz de matar, pero no puedes usar la interfaz de matar para matar personas, porque la interfaz de matar es solo una descripción de la función y cómo hacerlo depende de su clase de implementación. . Entonces, si hay una interfaz en un paquete, no es necesario implementarla. Esto no afecta el uso de otras clases.
implementos
implements es una palabra clave utilizada por una clase para implementar una interfaz. Se utiliza para implementar los métodos abstractos definidos en la interfaz. Por ejemplo: personas es una interfaz y tiene el método say. public interface people(){ public say();} Pero la interfaz no tiene cuerpo de método. El cuerpo del método solo se puede implementar a través de una clase específica. Por ejemplo, la clase de chino implementa la interfaz de personas. clase pública china implementa personas { public say() {System.out.println("¡Hola!");}}
En Java, implementa significa que la subclase hereda la clase principal. Por ejemplo, la clase A hereda la clase B y se escribe como clase A implementa B{}.
Diferencia de se extiende
se extiende, puede implementar la clase principal o puede llamar a la clase principal para inicializar this.parent(). Y sobrescribirá las variables o funciones definidas por la clase principal. La ventaja de esto es que el arquitecto puede definir la interfaz y dejar que el ingeniero la implemente. Toda la eficiencia del desarrollo del proyecto y los costos de desarrollo se reducen considerablemente.
implementa, implementa la clase principal y las subclases no pueden anular los métodos o variables de la clase principal. Incluso si la subclase define las mismas variables o funciones que la clase principal, serán reemplazadas por la clase principal.
El uso específico de estas dos implementaciones depende de la situación real del proyecto y los implementos no se pueden modificar. Solo se debe implementar específicamente la interfaz definida, o se puede modificar para que tenga una buena escalabilidad.
<!--[endif]-->