【JavaSE】Schnittstelle

Das Konzept der Schnittstelle

Schnittstellen sind öffentliche Verhaltensstandards. Wenn sie von allen implementiert werden und den Standards entsprechen, sind sie universell einsetzbar. In Java kann man sich eine Schnittstelle wie folgt vorstellen: eine gemeinsame Spezifikation für mehrere Klassen, bei der es sich um einen Referenzdatentyp handelt. Das Definitionsformat einer Schnittstelle ist grundsätzlich dasselbe wie das einer Klasse. Ersetzen Sie das Schlüsselwort class durch das Schlüsselwort interface, um eine Schnittstelle zu definieren.

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

Vorschläge:
1. Beim Erstellen einer Schnittstelle beginnt der Name der Schnittstelle im Allgemeinen mit dem Großbuchstaben I.
2. Bei der Benennung von Schnittstellen werden im Allgemeinen „Adjektiv“-Wörter mit Wortarten verwendet.
3. Die Alibaba Coding Standards schreiben vor, dass den Methoden und Attributen in der Schnittstelle keine Änderungssymbole hinzugefügt werden dürfen, um den Code einfach zu halten.

Nutzung der Schnittstelle

Die Schnittstelle kann nicht direkt verwendet werden. Es muss eine „Implementierungsklasse“ vorhanden sein, um die Schnittstelle zu „implementieren“ und alle abstrakten Methoden in der Schnittstelle zu implementieren.

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

Hinweis: Die Vererbungsbeziehung zwischen Unterklassen und übergeordneten Klassen wird erweitert, und die Implementierungsbeziehung zwischen Klassen und Schnittstellen wird implementiert.
Beispiel:
Bitte implementieren Sie ein Beispiel für die Verwendung einer USB-Maus und einer USB-Tastatur auf einem Laptop.
1. USB-Schnittstelle: einschließlich der Funktionen zum Öffnen und Schließen des Geräts.
2. Notebook-Klasse: einschließlich der Boot-Funktion, der Funktion zum Herunterfahren und der Verwendung der Funktion des USB-Geräts.
3 . Mausklasse: implementiert die USB-Schnittstelle und verfügt über die Klickfunktion
4. Tastaturklasse: implementiert die USB-Schnittstelle und verfügt über die Eingabefunktion
zum Erstellen einer USB-Schnittstelle

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

Erstellen Sie die Mausklasse Mouse, um die USB-Schnittstelle zu implementieren

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("鼠标点击");
	}
} 

Erstellen Sie eine Tastaturklasse KeyBoard, um die USB-Schnittstelle zu implementieren

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("键盘输入");
	}
}

Erstellen Sie einen Laptop und verwenden Sie USB-Geräte

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();
   }
}

Erstellen Sie die Testklasse 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();
	}
}

Schnittstelleneigenschaften

Der Schnittstellentyp ist ein Referenztyp, das Objekt der Schnittstelle kann jedoch nicht direkt neu sein.

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

Jede Methode in der Schnittstelle ist eine öffentliche abstrakte Methode . Das heißt, die Methode in der Schnittstelle wird implizit als öffentliche Zusammenfassung bezeichnet (sie kann nur eine öffentliche Zusammenfassung sein, andere Modifikatoren melden einen Fehler).

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

Methoden in einer Schnittstelle können nicht in der Schnittstelle implementiert werden, sondern können nur von der Klasse implementiert werden, die die Schnittstelle implementiert.

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

Beim Überschreiben von Methoden in einer Schnittstelle können Sie nicht die Standardzugriffsberechtigungen verwenden.

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

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

Schnittstellen können Variablen enthalten, Variablen in der Schnittstelle werden jedoch implizit als öffentliche statische Endvariablen bezeichnet.

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属性
	}
}

Die Schnittstelle darf keine Codeblöcke und Konstruktoren enthalten

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

Obwohl die Schnittstelle keine Klasse ist, ist das Suffixformat der Bytecode-Datei nach der Kompilierung der Schnittstelle ebenfalls .class. Wenn die Klasse nicht alle abstrakten Methoden in der Schnittstelle implementiert, muss die Klasse als abstrakte Klasse festgelegt werden. In jdk8 kann die Schnittstelle auch Standardmethoden enthalten.

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()！");
    }
}

Implementieren Sie mehrere Schnittstellen

Mehrfachvererbung wird in Java nicht unterstützt, eine Klasse kann jedoch mehrere Schnittstellen implementieren.
Definieren Sie eine Animal-Klasse

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

Bietet zwei Schnittstellen: Run und Fly

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

Erstelle einen Vogel

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 + "在跑");
    }
}

Erstelle einen Hund

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

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

Erstellen Sie abschließend eine Testklasse TestInterface

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

Hinweis: Wenn eine Klasse mehrere Schnittstellen implementiert, müssen die abstrakten Methoden in jeder Schnittstelle implementiert werden, andernfalls muss die Klasse als abstrakte Klasse festgelegt werden.

Vererbung zwischen Schnittstellen

In Java gibt es eine einzelne Vererbung zwischen Klassen. Eine Klasse kann mehrere Schnittstellen implementieren, und Schnittstellen können mehrere Vererbungen haben. Das heißt: Durch die Verwendung von Schnittstellen kann der Zweck der Mehrfachvererbung erreicht werden. Eine Schnittstelle kann eine Schnittstelle erben, um eine Wiederverwendung zu erreichen. Verwenden Sie das Schlüsselwort „Extens“.

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

Die Vererbung zwischen Schnittstellen entspricht dem Zusammenführen mehrerer Schnittstellen.

Der Unterschied zwischen abstrakter Klasse und Schnittstelle

Kernunterschied: Abstrakte Klassen können gewöhnliche Methoden und gewöhnliche Felder enthalten. Solche gewöhnlichen Methoden und Felder können direkt von Unterklassen verwendet werden (ohne Umschreiben), während Schnittstellen keine gewöhnlichen Methoden enthalten können und Unterklassen alle abstrakten Methoden neu schreiben müssen.

der Unterschied	abstrakte Klasse	Schnittstelle
Struktur und Zusammensetzung	Gewöhnliche Klasse + abstrakte Methode	Abstrakte Methode + globale Konstante
Berechtigungen	Diverse Berechtigungen	öffentlich
Verwendung von Unterklassen	Erben Sie abstrakte Klassen mithilfe des Schlüsselworts „extends“.	Implementieren Sie die Schnittstelle mit dem Schlüsselwort „implements“.
Einschränkungen für Unterklassen	Eine Unterklasse kann nur von einer abstrakten Klasse erben	Eine Unterklasse kann mehrere Schnittstellen implementieren
Beziehung	Eine abstrakte Klasse kann mehrere Schnittstellen implementieren	Schnittstellen können keine abstrakten Klassen erben, aber Schnittstellen können mithilfe des Schlüsselworts „extens“ mehrere Schnittstellen erben.