【JavaSE】Interface

La notion d'interface

Les interfaces sont des normes de comportement publiques. Lorsque tout le monde les met en œuvre, tant qu'elles respectent les normes, elles peuvent être utilisées universellement. En Java, une interface peut être considérée comme : une spécification commune pour plusieurs classes, qui est un type de données de référence. Le format de définition d'une interface est fondamentalement le même que celui d'une classe. Remplacez le mot-clé class par le mot-clé interface pour définir une interface.

public interface 接口名称{
    
    
	// 抽象方法
	public abstract void method1(); // public abstract 是固定搭配，可以不写
	public void method2();
	abstract void method3();
	void method4();
	// 注意：在接口中上述写法都是抽象方法，更推荐方式4，代码更简洁
}

Suggestions :
1. Lors de la création d'une interface, le nom de l'interface commence généralement par la lettre majuscule I.
2. La dénomination des interfaces utilise généralement des mots « adjectifs » avec une partie du discours.
3. Les normes de codage d'Alibaba stipulent qu'aucun symbole de modification ne doit être ajouté aux méthodes et aux attributs dans l'interface pour que le code reste simple.

Utilisation de l'interface

L'interface ne peut pas être utilisée directement. Il doit y avoir une "classe d'implémentation" pour "implémenter" l'interface et implémenter toutes les méthodes abstraites de l'interface.

public class 类名 implements 接口名{
    
    
	// ...
}

Remarque : La relation d'héritage entre les sous-classes et les classes parentes est étendue et la relation d'implémentation entre les classes et les interfaces est implémentée.
Exemple :
veuillez implémenter un exemple d'utilisation d'une souris USB et d'un clavier USB sur un ordinateur portable
1. Interface USB : incluant les fonctions d'ouverture et de fermeture de l'appareil
2. Classe d'ordinateur portable : incluant la fonction de démarrage, la fonction d'arrêt et l'utilisation de la fonction de périphérique USB
3 Classe Souris : implémente l'interface USB et possède la fonction de clic
4. Classe Clavier : implémente l'interface USB et possède la fonction d'entrée
pour créer une interface USB.

public interface USB {
    
    
	void openDevice();
	void closeDevice();
}

Créer une classe de souris Souris pour implémenter l'interface USB

public class Mouse implements USB {
    
    
	@Override
	public void openDevice() {
    
    
		System.out.println("打开鼠标");
	}
	@Override
	public void closeDevice() {
    
    
		System.out.println("关闭鼠标");
	}
	public void click(){
    
    
		System.out.println("鼠标点击");
	}
} 

Créez une classe de clavier KeyBoard pour implémenter l'interface USB

public class KeyBoard implements USB {
    
    
	@Override
	public void openDevice() {
    
    
		System.out.println("打开键盘");
	} 
	@Override
	public void closeDevice() {
    
    
		System.out.println("关闭键盘");
	}
	public void inPut(){
    
    
		System.out.println("键盘输入");
	}
}

Créez un ordinateur portable et utilisez des périphériques USB

public class Computer {
    
    
   public void powerOn(){
    
    
       System.out.println("打开笔记本电脑");
   }
   public void powerOff(){
    
    
       System.out.println("关闭笔记本电脑");
   }
   public void useDevice(USB usb){
    
    
       usb.openDevice();
       if(usb instanceof Mouse){
    
    
           Mouse mouse = (Mouse)usb;
           mouse.click();
       }else if(usb instanceof KeyBoard){
    
    
           KeyBoard keyBoard = (KeyBoard)usb;
           keyBoard.inPut();
       } 
       usb.closeDevice();
   }
}

Créer une classe de test TestUSB

public class TestUSB {
    
    
	public static void main(String[] args) {
    
    
		Computer computer = new Computer();
		computer.powerOn();
		// 使用鼠标设备
		computer.useDevice(new Mouse());
		// 使用键盘设备
		computer.useDevice(new KeyBoard());
		computer.powerOff();
	}
}

Caractéristiques des interfaces

Le type d'interface est un type référence, mais l'objet de l'interface ne peut pas être directement nouveau.

public class TestUSB {
    
    
	public static void main(String[] args) {
    
    
		USB usb = new USB();//error USB是抽象的 无法实例化
	}
}

Chaque méthode de l'interface est une méthode abstraite publique , c'est-à-dire que la méthode de l'interface sera implicitement désignée comme abstraite publique (elle ne peut être qu'abstraite publique, d'autres modificateurs signaleront une erreur)

public interface USB {
    
    
	private void openDevice();// error 此处不允许使用private
	void closeDevice();
}

Les méthodes d'une interface ne peuvent pas être implémentées dans l'interface et ne peuvent être implémentées que par la classe qui implémente l'interface.

public interface USB {
    
    
	void openDevice();
	// 编译失败：因为接口中的方式默认为抽象方法
	// error 接口抽象方法不能带有主体
	void closeDevice(){
    
    
		System.out.println("关闭USB设备");
	}
}

Lors du remplacement de méthodes dans une interface, vous ne pouvez pas utiliser les autorisations d'accès par défaut.

public interface USB {
    
    
	void openDevice(); // 默认是public的
	void closeDevice(); // 默认是public的
}

public class Mouse implements USB {
    
    
	@Override
	void openDevice() {
    
      //error
		System.out.println("打开鼠标");
	}
} 

Les interfaces peuvent contenir des variables, mais les variables de l'interface sont implicitement désignées comme variables finales statiques publiques.

public interface USB {
    
    
	double brand = 3.0; // 默认被：final public static修饰
	void openDevice();
	void closeDevice();
}

public class TestUSB {
    
    
	public static void main(String[] args) {
    
    
		// 可以直接通过接口名访问，说明是静态的
		System.out.println(USB.brand); 
		// 编译报错：error 无法为最终变量brand分配值
		USB.brand = 2.0; // 说明brand具有final属性
	}
}

Il ne peut pas y avoir de blocs de code ni de constructeurs dans l'interface

public interface USB {
    
    
	public USB(){
    
    } // 编译失败
	{
    
    } // 编译失败
	static {
    
    } // 编译失败
	void openDevice();
	void closeDevice();
}

Bien que l'interface ne soit pas une classe, le format de suffixe du fichier de bytecode une fois l'interface compilée est également .class. Si la classe n'implémente pas toutes les méthodes abstraites de l'interface, elle doit être définie comme classe abstraite. Dans jdk8, l'interface peut également contenir des méthodes par défaut.

public interface ITest {
    
    
    //一定要被重写
    void testA(); 
    //static修饰不能被重写
    static void testStatic() {
    
    
        System.out.println("testStatic()");
    }
    //default修饰可以被重写也可以不被重写
    default void defaultMethod() {
    
    
        System.out.println("defaultMethod()");
    }
}

class TestDemo implements ITest {
    
    
    @Override
    public void testA() {
    
    
        System.out.println("重写testA()！");
    }
}

Implémenter plusieurs interfaces

L'héritage multiple n'est pas pris en charge en Java, mais une classe peut implémenter plusieurs interfaces.
Définir une classe Animal

public class Animal {
    
    
    String name;
    public Animal(String name) {
    
    
        this.name = name;
    }
}

Fournit deux interfaces Run and Fly

public interface Run {
    
    
    void running();
}
public interface Fly {
    
    
    void flying();
}

Créer un oiseau

public class Bird extends Animal implements Run,Fly {
    
    
    public Bird(String name) {
    
    
        super(name);
    }

    @Override
    public void flying() {
    
    
        System.out.println(name + "在飞翔");
    }

    @Override
    public void running() {
    
    
        System.out.println(name + "在跑");
    }
}

Créer un chien

public class Dog extends Animal implements Run {
    
    
    public Dog(String name) {
    
    
        super(name);
    }

    @Override
    public void running() {
    
    
        System.out.println(name + "在飞快地跑");
    }
}

Créez enfin une classe de test TestInterface

public class TestInterface {
    
    
    public static void main(String[] args) {
    
    
        Dog dog = new Dog("大黑");
        Bird bird = new Bird("小白");
        dog.running();
        bird.running();
        bird.flying();
    }
}

Remarque : Lorsqu'une classe implémente plusieurs interfaces, les méthodes abstraites de chaque interface doivent être implémentées, sinon la classe doit être définie comme classe abstraite.

Héritage entre interfaces

En Java, il existe un héritage unique entre les classes. Une classe peut implémenter plusieurs interfaces et les interfaces peuvent avoir plusieurs héritages. Autrement dit : l'utilisation d'interfaces peut atteindre l'objectif d'héritage multiple. Une interface peut hériter d'une interface pour pouvoir être réutilisée. Utilisez le mot clé extends.

interface IRunning {
    
    
	void run();
} 
interface ISwimming {
    
    
	void swim();
} 
// 两栖动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
    
    
}

L'héritage entre les interfaces équivaut à la fusion de plusieurs interfaces.

La différence entre la classe abstraite et l'interface

Différence fondamentale : les classes abstraites peuvent contenir des méthodes ordinaires et des champs ordinaires. Ces méthodes et champs ordinaires peuvent être utilisés directement par les sous-classes (sans réécriture), tandis que les interfaces ne peuvent pas contenir de méthodes ordinaires et les sous-classes doivent réécrire toutes les méthodes abstraites.

la différence	classe abstraite	interface
Structure et composition	Classe ordinaire + méthode abstraite	Méthode abstraite + constante globale
Autorisations	Diverses autorisations	publique
Utilisation de la sous-classe	Hériter des classes abstraites à l'aide du mot-clé extends	Implémentez l'interface à l'aide du mot-clé Implements
Restrictions de sous-classe	Une sous-classe ne peut hériter que d'une seule classe abstraite	Une sous-classe peut implémenter plusieurs interfaces
relation	Une classe abstraite peut implémenter plusieurs interfaces	Les interfaces ne peuvent pas hériter de classes abstraites, mais les interfaces peuvent hériter de plusieurs interfaces à l'aide du mot-clé extends.