Interfaz de notas de estudio de Java

Interfaz

1. La interfaz es un tipo de datos de referencia
2. La interfaz es completamente abstracta (la clase abstracta es semi-abstracta) o se puede decir que la interfaz es una clase abstracta especial
3. La sintaxis de la interfaz: [Lista de modificadores] nombre de interfaz de interfaz {}
4. Interfaz Entre la interfaz y la interfaz y la clase admiten herencia múltiple
5. La interfaz solo contiene constantes y métodos abstractos, por lo que no hay constructor
6. Todos los elementos en la interfaz se modifican públicamente
7. Cuando se define el método abstracto de la interfaz: public abstractmodificado El operador puede ser omitido

• Al definir constantes en la interfaz: public static finalse pueden omitir modificadores
• Se agregará automáticamente cuando el compilador compile

Uso básico de la interfaz.

1. Las clases y las clases se llaman herencia, y las clases y las interfaces se llaman implementaciones ("implementación" se puede entender como "herencia")

• La herencia se extendsrealiza con palabras clave
• La implementación se realiza usando implementspalabras clave
  2. Cuando una clase no abstracta implementa una interfaz, todos los métodos abstractos en la interfaz deben implementarse (anularse)

interface MyMaths{
        //这里要知道常量和方法都是省略了关键字的
	double PI = 3.14;
	int sum(int a ,int b);
	int sub(int a, int b);
}

class MyMathsImpl implements MyMaths{
	//方法覆盖（这里通常叫做实现）
	public int sum(int a, int b){
		return a + b;
	}
	public int sub(int a, int b){
		return a - b;
	}
}
public class InterfaceTest{
	public static void main(String[] args){
		//多态
		MyMaths m = new MyMathsImpl();
		int a = m.sum(1, 2); 
		System.out.println(a);
	}
}

¿Puede una clase implementar (heredar) múltiples interfaces?

Sí, este mecanismo compensa las clases Java y las clases solo admiten herencia única.

interface A{
	void m1();
}
interface B{
	void m2();
}
interface C{
	void m3();
}
class D implements A,B,C{
	public void m1(){
		System.out.println("m1...");
	}
	public void m2(){
		System.out.println("m2...");
	}
	public void m3(){
		System.out.println("m3...");
	}
}

public class InterfaceTest{
	public static void main(String[] args){
		//多态
		//父类型引用指向子类型对象
		A a = new D();
		B b = new D();
		C c = new D();
		
		//接口之间没有继承关系，是否可以强制类型转换（接口转型）
		//属于骚操作，明明没有继承关系，还能转型，现阶段还是不要去记它，用处不大
		B b1 = (B)a;
		b1.m2();
		
		//如果想让a调用m2方法，还是直接向下转换成D即可
		D d = (D)a;
		d.m2();
	}
}

Independientemente de la transformación hacia arriba o hacia abajo, debe haber una relación de herencia entre los dos tipos. Sin la relación de herencia, el compilador informará un error, pero esta oración no se aplica a la interfaz.
Si desea que la referencia de tipo principal llame a un método específico del subtipo, es mejor usar la sintaxis de convertir la referencia de tipo principal a un objeto de subtipo.

Transición entre interfaces sin herencia

interface K{
}
interface M{
}
class E implements M{
	
}
public class InterfaceTest{
	public static void main(String[] args){
		M m = new E();
		K k = (K)m;
	}
}

No hay una relación de herencia entre la interfaz y la interfaz, y no hay una relación de herencia. También puede forzar la conversión de tipo, el compilador no informará un error, pero tenga en
cuenta que ClassCastException puede ocurrir en tiempo de ejecución.

Si existen tanto la herencia como la implementación, ¿cómo se debe escribir el código?

se extiende delante de los implementos en la espalda

class Animal{
	
}
//可飞翔的接口,接口通常提取的是行为动作
interface Flyable{
	void fly();
}

class Cat extends Animal implements Flyable{
	public void fly(){
		System.out.println("飞翔的小猫");
	}
}


//如果不想让它飞，可以不实现Flyable的接口
class Snake extends Animal{
	
}

//想飞就插入Flyable接口
class Pig extends Animal implements Flyable{
		public void fly(){
		System.out.println("飞翔的小猪");
	}
}
public class Test{
	public static void main(String[] args){
		//多态
		Flyable f = new Cat();
		f.fly();
		
		Flyable f1 = new Pig();
		f1.fly();
	}
}

Este ejemplo incorpora la función "conectable" de la interfaz, que reduce la correlación entre programas, que es el desacoplamiento.

El papel de las interfaces en el desarrollo.

• La interfaz es completamente abstracta,
• La programación orientada a abstractos se modifica de la siguiente manera: programación orientada a interfaces
• Con la interfaz, es conectable. Enchufable significa que la fuerza de expansión es muy fuerte, no soldada
• Hay una ranura directamente en la placa base y la memoria. Esta ranura tiene una interfaz. Si el módulo de memoria está roto, puede reemplazarlo. Esto se llama alta escalabilidad (bajo acoplamiento)

Para resumir una oración:

Programación orientada a la interfaz, que puede reducir el grado de acoplamiento del programa y proporcionar la fuerza de expansión del programa, de acuerdo con el principio OCP
. El uso de la interfaz es inseparable del mecanismo polimórfico

//接口 -菜单
public interface FoodMeau {

    public void shihongshi();
    public void rousi();

}

//接口的实现
//西餐师傅
//厨师是接口的实现者
public class AmericanCooker implements FoodMeau{
    public void shihongshi(){
        System.out.println("西餐师傅做的西红柿炒蛋");
    }
    public void rousi(){
        System.out.println("西餐师傅做的鱼香肉丝");
    }
}

//中餐厨师
public class ChineseCooker implements FoodMeau{
    public void shihongshi(){
        System.out.println("中餐师傅做的西红柿炒蛋，超好吃的");
    }
    public void rousi(){
        System.out.println("中餐师傅做的鱼香肉丝，超好吃的");
    }
}

//接口的调用者 -顾客
public class Customer {
    //顾客手里有一个菜单
    //Customer has a FoodMenu
    //记住：以后凡是能够使用 has a 来描述的，统一以属性的方式存在
    //回顾：凡是能用 is a来描述的，都可以设置为继承
    private FoodMeau foodMeau;

    //Constructor
    public Customer() {
    }
    public Customer(FoodMeau foodMeau) {
        this.foodMeau = foodMeau;
    }

    //setting and getter
    public FoodMeau getFoodMeau() {
        return foodMeau;
    }

    public void setFoodMeau(FoodMeau foodMeau) {
        this.foodMeau = foodMeau;
    }

    //提供点菜的方法
    public void order(){
        FoodMeau f = getFoodMeau();
        f.shihongshi();
        f.rousi();
    }
}

public class Test {
    public static void main(String[] args) {
        //建立厨师对象
        FoodMeau cooker1 = new ChineseCooker();
        FoodMeau cooker2 = new AmericanCooker();
        //建立顾客对象
        Customer c = new Customer(cooker1);

        //顾客点菜
        c.order();
        //如果想要点西餐
        c.setFoodMeau(cooker2);
        c.order();
    }
}

La interfaz se puede desacoplar:

Cualquier interfaz tiene un llamador y un implementador. La interfaz puede desacoplar al
llamador y al implementador. El llamante escribe la llamada para la interfaz y el implementador escribe la implementación para la interfaz.
El desarrollo de proyectos grandes generalmente separa el proyecto en un módulo. Para los módulos, la
interfaz entre módulos y módulos se adopta para reducir el grado de acoplamiento.