05.Java-Grundlagen – Schnittstelle

Grundlegende Konzepte

Schnittstelle (Schnittstelle) bezieht sich im Allgemeinen auf Methoden oder Funktionen, die von anderen aufgerufen werden . Es führt abstrakte Konzepte einen Schritt weiter.

Definieren Sie in Java eine Schnittstelle über das Schlüsselwort „interface“ und implementieren Sie die Schnittstelle über das Schlüsselwort „implements“.

Wir können eine Schnittstelle als eine extrem abstrakte Klasse verstehen, weil sie abstrakter ist als eine abstrakte Klasse.

---

Beispielstudie

Sehen wir uns die Eigenschaften der Schnittstelle anhand von Beispielen an:

• Definieren eine Schnittstelle

// 1.接口，访问权限只能是 默认（包访问权限）或 publicpublic interface Parent {

    // 2.成员变量，准确来说应该叫常量。具有以下特点：

    // 2.1.访问权限只能是 public （缺省也代表 public） ，修饰符只能是 final & static
    public final static String WORD = "a";    // 2.2.即使不指定，默认也是被 public fainl static 修饰
    String NAME = "b";    // 2.3.不能存在空的 final 变量 ，如 int num; 但是可以被非常量表达式初始化
    int num = new Random().nextInt(100);    // 3.抽象方法，访问权限只能是 默认（包访问权限）或 public
    public abstract void print();    abstract void print(int i);    // 4.普通方法，访问权限只能是 默认（包访问权限）或 public
    public void play();    void play(int i);
}

• Implementieren Sie eine Schnittstelle

public class Son implements Parent {
    @Override
    public void print() {
        System.out.println("I am Son");
    }    @Override
    public void play() {
        System.out.println("Son is playing");
    }
}

---

Geschachtelte Schnittstelle

Es gibt zwei Formen von verschachtelten Schnittstellen:

• Definieren Sie eine Schnittstelle in einer Klasse;

Definieren Sie eine Schnittstelle innerhalb einer Schnittstelle.

---

1. Definieren Sie die Schnittstelle in der Klasse

Die Schnittstelle ist in der Klasse verschachtelt und weist die folgenden Eigenschaften auf:

Es gibt keine Einschränkungen für die Zugriffsrechte der Schnittstelle, Sie können private Änderungen verwenden
Die Zugriffsrechte von Methoden/abstrakten Methoden/Variablen sind konsistent mit der externen Schnittstelle
Das Folgende wird anhand eines Beispiels überprüft:

Sehen wir uns den Aufrufprozess an:

public class Demo {
    // 内部接口
    private interface A {
        void f();
    }    // 内部类
    class AImpl implements A {        @Override
        public void f() {
            System.out.println("AImpl.f()");
        }
    }

    A getA(){        return new AImpl();
    }    private A a;    public void receive(A a){        this.a = a;
        a.f();
    }
}

Demo demo = new Demo();// 错误，因为 A 是私有接口，不可被外部访问
// Demo.A a = demo.getA();  // 因为 A 接口不可视，所以只能通过内部类来访问
Demo.AImpl a = (Demo.AImpl) demo.getA();a.f();// 或者是这样
demo.receiveA(demo.getA());

---

2. Definieren Sie die Schnittstelle in der Schnittstelle

Definieren Sie die Schnittstelle in der Schnittstelle. Bis auf den Aufruf ist sie dieselbe wie die normale Schnittstelle.

public interface Demo {
    // 内部接口
    interface A {        void play();
    }    void print();
}public class DemoImpl implements Demo,Demo.A{

    @Override
    public void play() {
        System.out.println("DemoImpl.play()");
    }    @Override
    public void print() {
        System.out.println("DemoImpl.print()");
    }

}public class Test{
    public static void main(String[] args) {        // 向上转型，只能调用 print（）
        Demo demo  = new DemoImpl();        // 向上转型，只能调用 play（） 
        Demo.A a = new DemoImpl();      
    }
}

---

Schnittstelle & abstrakte Klasse

Wie oben erwähnt, können wir die Schnittstelle als eine äußerst abstrakte Klasse verstehen, da sie abstrakter ist als die abstrakte Klasse Abstrakter.

In der tatsächlichen Anwendung gibt es immer noch Unterschiede zwischen den beiden.

---

1. Syntaxunterschied

Abstrakte Klassen können nicht abstrakte Methoden enthalten, während in Schnittstellen nur abstrakte Methoden vorhanden sein können.
Mitgliedsvariablen in abstrakten Klassen können von unterschiedlichem Typ sein, während Mitgliedsvariablen in Schnittstellen nur
• öffentliche statische Konstanten

  (öffentliches statisches Finale) sein können.

Abstrakte Klassen können statische Codeblöcke und statische Methoden haben, Schnittstellen können jedoch keine statischen Codeblöcke und statischen Methoden enthalten.
Eine Klasse kann nur
• eine

  abstrakte Klasse erben, aber eine Klasse kann mehrere Schnittstellen implementieren.

---

2. Nutzen Sie den Unterschied

Abstrakte Klasse ist die Abstraktion des Ganzen (Eigenschaften, Verhalten), während Schnittstelle es ist die Abstraktion der Sache Lokale (Verhaltens-)Abstraktion.

Um ein einfaches Beispiel zu nennen: Flugzeuge und Vögel sind verschiedene Arten von Dingen, aber eines haben sie alle gemeinsam: Sie können beide fliegen.

Beim Entwerfen können Sie das Flugzeug im Flugzeugstil und den Vogel im Vogelstil gestalten.

Aber das Merkmal Fliegen kann nicht als Klasse konzipiert werden, es handelt sich also nur um ein Verhaltensmerkmal und nicht um eine abstrakte Beschreibung einer Klasse von Dingen.

An diesem Punkt kann der Flug als Schnittstelle Fly entworfen werden, einschließlich der Methode fly(), und dann implementieren Airplane und Bird die Fly-Schnittstelle entsprechend ihren eigenen Anforderungen.

Verschiedene Flugzeugtypen wie Kampfflugzeuge, Zivilflugzeuge usw. können die Klasse „Flugzeug“ direkt erben. Dasselbe gilt für Vögel .

Hier ist ersichtlich, dass Vererbung eine „Ist es“-Beziehung ist, während die Schnittstellenimplementierung eine „Ist es“-Beziehung ist.

Wenn eine Klasse eine abstrakte Klasse erbt, muss die Unterklasse vom Typ einer abstrakten Klasse sein, und die Schnittstellenimplementierung hängt davon ab, ob sie existiert oder nicht, z. B. ob ein Vogel fliegen kann (oder ob er das hat). Fähigkeit zu fliegen (Diese Funktion): Wenn Sie fliegen können, können Sie diese Schnittstelle implementieren. Wenn Sie nicht fliegen können, können Sie diese Schnittstelle nicht implementieren.

Das Obige ist der Inhalt von 05.Java Basics - Interface. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).