Interfaz y polimorfismo
1. Interfaz
1. Definición de interfaz
⑴ puede considerarse como un tipo especial de clase abstracta;
⑵ y solo contiene métodos abstractos.
2. La sintaxis de la interfaz
(1) La definición se define mediante la palabra clave de la interfaz;
(2) Las variables miembro no se pueden definir en la interfaz, pero se pueden definir constantes;
(3) Solo se pueden definir métodos sin cuerpos de método (el valor predeterminado es métodos abstractos).
public abstract void methodName ();
el resumen público se puede omitir.
interface Inter12{
// int a; //不能定义成员变量
static final int A1 = 1;
public abstract void Aoo();//接口只包含抽象方法，抽象方法没有方法体实现
void Boo();//接口中抽象方法可忽略不写public abstract
}
3. Implementación de la interfaz
Una clase puede implementar múltiples interfaces, que están separadas por comas.
3.1. Implementar la interfaz a través de la palabra clave implements;
3.2. Después de que una clase implementa la interfaz, debe implementar la interfaz definida en la interfaz.Todos los métodos
3.3. No se puede instanciar la interfaz;
3.4. La interfaz se puede usar como un tipo para declarar una variable. Una variable del tipo de interfaz
puede referirse al objeto de clase que implementa la interfaz (modelado ascendente).
Variable de declaración de nombre de interfaz = nuevo nombre de clase ();
public class InterfaceDemo2 {
public static void main(String[] args) {
// Inter12 o1 = new Inter12();接口不能被实例化
Inter12 o2 = new Coo1();//向上造型
}
}
interface Inter12{
// int a; //不能定义成员变量
static final int A1 = 1;
public abstract void Aoo();//接口只包含抽象方法，抽象方法没有方法体实现
void Boo();//接口中抽象方法可忽略不写public abstract
}
class Coo1 implements Inter12{
public void Aoo() {
}
public void Boo() {
}
}
interface Inter13{
public void a1();
}
class Doo1 implements Inter12,Inter13{
public void a1() {
}
public void Aoo() {
}
public void Boo() {
}
}
4. Herencia e implementación de interfaces
(1) La interfaz puede heredar la interfaz (extiende la palabra clave).
La interfaz secundaria hereda todos los métodos definidos en la interfaz principal (es decir, los métodos que implementan la interfaz principal).
(2) Si hereda e implementa una interfaz, primero debe heredar y luego implementar.
※ Después de que una cierta clase implementa una interfaz, debe implementar todos los métodos definidos en la interfaz (anular).
interface Inter12{
// int a; //不能定义成员变量
static final int A1 = 1;
public abstract void Aoo();//接口只包含抽象方法，抽象方法没有方法体实现
void Boo();//接口中抽象方法可忽略不写public abstract
}
class Coo1 implements Inter12{
public void Aoo() {
}
public void Boo() {
}
}
interface Inter13{
public void a1();
}
class Doo1 implements Inter12,Inter13{
public void a1() {
}
public void Aoo() {
}
public void Boo() {
}
}
interface Inter14 extends Inter13{
public void Aoo();//继承了接口后，必须实现父类中定义的所有方法（抽想方法）
public void Boo();
}
abstract class Eoo1{
void b() {
}
}
/*
* 又继承又实现，则先继承父类，再实现接口
*/
class Foo extends Eoo1 implements Inter13{
public void b() {
}
public void a1() {
}
}
Dos, polimorfismo:
1. Significado:
1) Cuando las referencias del mismo tipo apuntan a diferentes objetos, tienen diferentes implementaciones
—polimorfismo de comportamiento: cortar (), ejecutar (), dormir () ...
2) El mismo objeto se forma en diferentes tipos El tiempo, hay distintas funciones
-polimorfismo de los objetos: yo, tú, árbol ...
2.Modelado ascendente:
2.1. La referencia del supertipo apunta al objeto de la clase derivada
2.2. Los tipos que se pueden modelar son: superclase + la interfaz implementada
2.3. Lo que se puede señalar depende del tipo de referencia
3. Solo hay dos condiciones para una coerción de tipo de referencia exitosa:
3.1. El objeto apuntado por la referencia es el tipo
3.2. El objeto apuntado por la referencia implementa la interfaz o hereda la clase.
Por ejemplo, el siguiente ejemplo:
人 p1 = new 理发师();
人 p2 = new 医生();
人 p3 = new 演员();
p1.cut(); //剪发
p2.cut(); //看病
p3.cut(); //表演
abstract class 人{
abstract void cut();
}
class 理发师 extends 人{
void cut(){
剪发 }
}
class 医生 extends 人{
void cut(){
看病 }
}
class 演员 extends 人{
void cut(){
表演 }
}
Si las dos condiciones anteriores no se cumplen
durante la conversión forzada , se producirá una excepción de conversión de tipo ClassCastException. Recomendación: Antes de la conversión forzada, use instanceof para determinar si el objeto referenciado es de este tipo.
public class MultiTypeDemo {
public static void main(String[] args) {
Aoo o = new Boo(); //向上造型
Boo o1 = (Boo)o; //o所指向的对象，就是Boo类型
Inter1 o2 = (Inter1)o; //o所指向的对象，实现了Inter1接口
o2.a();
//Coo o3 = (Coo)o; //ClassCastException类型转换异常
if(o instanceof Coo) {
Coo o4 = (Coo)o;
}else {
System.out.println(123456);
}
}
}
interface Inter1{
public void a();
}
class Aoo{
}
class Boo extends Aoo implements Inter1{
public void a() {
System.out.println("实现Inter的方法");
}
}
class Coo extends Aoo{
}
¡Tenga paciencia con el contenido de seguimiento y venga pronto! Escribir no es fácil, por favor dé su aprobación 3Q
Si hay errores, por favor comente
El catálogo de todos los capítulos está aquí: https://blog.csdn.net/qq_41254299/article/details/106638651
Indique la fuente de la reimpresión: https://blog.csdn.net/qq_41254299
Este artículo es del [blog de Superclover_]