Resumen de aprendizaje de Java: 14

Interfaz

Definición básica de interfaz

Estrictamente hablando, la interfaz pertenece a una clase especial, y solo hay métodos abstractos y variables globales en esta clase.
Puede usar la palabra clave de interfaz para definir la interfaz en java.
Ejemplo: definir la interfaz

interface A{	//定义接口
	public static final String MSG="Hello World";	//全局变量
	public abstract void print();	//抽象方法
}

Principios del uso de interfaces:
1. Las interfaces deben tener subclases, pero en este momento una subclase puede usar la palabra clave implements para implementar múltiples interfaces para evitar la limitación de herencia única;
2. Subclases de interfaces (si no son clases abstractas), deben Sobrescribir todos los métodos abstractos en la
interfaz : 3. Los objetos de la interfaz pueden ser instanciados por la transformación ascendente de los objetos de la subclase.
Ejemplo: implementar la interfaz

interface A9{
    public static final String MSG="Hello World";
    public abstract void print();
}
interface B9{
    public abstract void get();
}
class X1 implements A9,B9{
    public void print(){
        System.out.println("A接口的抽象方法");
    }
    public void get(){
        System.out.println("B接口的抽象方法");
    }
}
public class Test1_1_4_3 {
    public static void main(String args[]){
        X1 x=new X1();
        A9 a=x;
        B9 b=x;
        a.print();
        b.get();
        System.out.println(A9.MSG);
    }
}
//结果
//A接口的抽象方法
//B接口的抽象方法
//Hello World

Si una subclase hereda tanto la clase abstracta como la interfaz, debe completarse en el orden de herencia y luego en la implementación de la interfaz.

Ejemplo: las subclases heredan clases abstractas e implementan interfaces

interface A9{	//定义接口
    public abstract void print();	//抽象方法
}
interface B9{
    public abstract void get();
}
abstract class C9{
    public abstract void change();
}
class X1 extends C9 implements A9,B9{	//X1类继承了抽象类C9，实现了A9和B9两个接口
    public void print(){	//覆写A9中的方法
        System.out.println("A接口的抽象方法");
    }
    public void get(){
        System.out.println("B接口的抽象方法");
    }
    public void change(){	//覆写抽象类C9的方法
        System.out.println("C类的抽象方法");
    }
}
public class Test1_1_4_3 {
    public static void main(String args[]){
        X1 x=new X1();
        A9 a=x;
        B9 b=x;
        C9 c=x;
        a.print();
        b.get();
        c.change();
    }
}
//结果
//A接口的抽象方法
//B接口的抽象方法
//C类的抽象方法

Ejemplo: herencia múltiple de interfaces

interface A{	//定义父接口
	public void funA();
}
interface B{	//定义父接口
	public void funB();
}
interface C extends A,B{	//利用extends，实现接口多继承
	public void funC();
}
class X implements C{	//实现C接口子类要覆写全部抽象方法
	public void funA(){}	//A接口定义的方法
	public void funB(){}	//B接口定义的方法
	public void funC(){}	//C接口定义的方法
}

Aunque el concepto de la interfaz en sí solo puede estar compuesto por métodos abstractos y variables globales, todas las estructuras internas no están restringidas por estos requisitos, es decir, las clases internas ordinarias, las clases internas abstractas y las interfaces internas se pueden definir en la interfaz .

Ejemplo: definir una clase abstracta en la interfaz

interface A{
   public void funA();
   abstract class B{	//定义接口中的抽象类
		public abstract void B();
	}
}
class X implements A{	//X实现了A接口
    public void funA(){
        System.out.println("Hello World");
    }
    class Y extends B{	//内部抽象类的子类，可以选择型继承
		public void funB(){}
	}
}

Si usa static para definir una interfaz interna dentro de una interfaz, la interfaz representa una interfaz externa.

Ejemplo:

interface A{
   public void funA();
   static interface B{	//外部接口
		public void funB();
	}
}
class X implements A.B{	//X实现了A接口
    public void funB(){}
}

La aplicación práctica de la interfaz estándar

Ejemplo: definir estándar USB

interface USB{	//定义标准一定就是接口
	public void start();	//USB设备开始工作
	public void stop();		//USB设备停止工作
}

Ejemplo: definir una clase de computadora

class Computer{
	public void plugin(USB usb){	//插入USB接口设备(子类对象)
		usb.start();	//开始工作
		usb.stop();		//停止工作
	}
}

Ejemplo: definir placa U

class Flash implement USB{
	public void start(){
		System.out.println("U盘开始使用");
	}
	public void stop(){
		System.out.println("U盘停止使用");
	}
}

public class Test{
	public static void main(String args[]){
		Computer com=new Computer();	//实例化计算机类
		com.plugin(new Flash);		//插入USB接口设备
	}
}

Aplicación del patrón de diseño de interfaz de fábrica

interface Fruit{
    public void eat();
}
class Apple implements Fruit{
    public void eat(){
        System.out.println("吃苹果");
    }
}
class Orange implements Fruit{
    public void eat(){
        System.out.println("吃橘子");
    }
}
class Factory{	//定义工厂类，此类不提供属性
    public static Fruit getInstance(String className){
        if ("apple".equals(className)){
            return new Apple();
        }
        else if("orange".equals(className)){
            return new Orange();
        }
        else{
            return null;
        }
    }
}
public class Test1_1_4_4 {
    public static void main(String args[]){
        Fruit f=Factory.getInstance("orange");	//通过工厂类取得指定标记的对象
        f.eat();	//调用接口方法
    }
}

Con esta clase de fábrica, no tiene que modificar la subclase de la interfaz instanciada cada vez.

La diferencia entre clases abstractas e interfaces

Nota: Si escribe su propia interfaz, nunca debe usar la palabra clave new para instanciar directamente la subclase de interfaz, debe usar la clase factory.