Résumé de l'apprentissage Java: 14

Interface

Définition de base de l'interface

À strictement parler, l'interface appartient à une classe spéciale, et il n'y a que des méthodes abstraites et des variables globales dans cette classe.
Vous pouvez utiliser le mot-clé interface pour définir l'interface en java.
Exemple: définir l'interface

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

Principes d'utilisation des interfaces:
1. Les interfaces doivent avoir des sous-classes, mais à ce stade, une sous-classe peut utiliser le mot clé implements pour implémenter plusieurs interfaces afin d'éviter la limitation d'héritage unique;
2. Les sous-classes d'interfaces (s'il ne s'agit pas de classes abstraites), doivent Écraser toutes les méthodes abstraites de l'
interface 3. Les objets de l'interface peuvent être instanciés par la transformation ascendante des objets de la sous-classe.
Exemple: implémenter l'interface

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 une sous-classe hérite à la fois de la classe abstraite et de l'interface, elle doit être complétée dans l'ordre d'héritage, puis implémentation de l'interface.

Exemple: les sous-classes héritent de classes abstraites et implémentent des 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类的抽象方法

Exemple: héritage multiple d'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接口定义的方法
}

Bien que le concept de l'interface elle-même ne puisse être composé que de méthodes abstraites et de variables globales, toutes les structures internes ne sont pas limitées par ces exigences, c'est-à-dire que les classes internes ordinaires , les classes internes abstraites et les interfaces internes peuvent être définies dans l'interface .

Exemple: définir une classe abstraite dans l'interface

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 vous utilisez statique pour définir une interface interne dans une interface, l'interface représente une interface externe.

Exemple:

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

L'application pratique de la norme d'interface

Exemple: définir la norme USB

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

Exemple: définir une classe informatique

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

Exemple: définir une plaque en 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接口设备
	}
}

Application du modèle de conception interface-usine

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();	//调用接口方法
    }
}

Avec cette classe d'usine, vous n'avez pas à modifier la sous-classe de l'interface instanciée à chaque fois.

La différence entre les classes abstraites et les interfaces

Remarque: Si vous écrivez votre propre interface, vous ne devez jamais utiliser le mot-clé new pour instancier directement la sous-classe d'interface, vous devez utiliser la classe d'usine.