Java-Interface (Interface)

In diesem Tutorial werden wir Java-Schnittstellen lernen. Wir lernen anhand von Beispielen, wie man Schnittstellen implementiert und wann man sie verwendet.

In Java definieren Schnittstellen eine Reihe von Spezifikationen, die andere Klassen implementieren müssen. Zum Beispiel:

interface　Polygon　{
　　　public void getArea();
}

Hierbei ist Polygon eine Schnittstelle. Wir haben das Schlüsselwort interface verwendet, um eine Schnittstelle zu deklarieren.

Die Methode getArea() ist eine Spezifikation, die im Polygon-Interface definiert ist, und alle Klassen, die dieses Interface verwenden, müssen die Methode getArea() implementieren.

Eine Schnittstelle kann abstrakte Methoden und Konstanten enthalten. Zum Beispiel:

interface　Polygon　{
　　　public static final String color = "blue";
　　　
　　　public void getArea();
}

Im obigen Beispiel haben wir eine Schnittstelle Polygon erstellt. Diese enthält eine Konstantenvariable color und eine abstrakte Methode getArea().

Es ist wichtig zu beachten, dass alle Methoden im Interface implizit public sind und alle Felder implizit public static final. Daher ist es nicht erforderlich, im Interface eine Zugriffsbeschreibung anzugeben. Zum Beispiel können wir den obigen Code so schreiben:

interface　Polygon　{
　　　String farbe = "blau";
　　　
　　　　void getArea();
}

Schnittstelle und implement Schlüsselwort

Wie bei abstrakten Klassen können wir keine Objekte von Schnittstellen erstellen. Aber wir können Schnittstellen in anderen Klassen implementieren. In Java verwenden wir den Schlüsselwort implement, um Schnittstellen zu implementieren. Zum Beispiel,

interface　Polygon　{
　　　　void getArea(int länge, int breite);
}
class Rectangle implements Polygon {
　　　　public void getArea(int länge, int breite) {
　　　　　　　　System.out.println("Der Flächeninhalt des Rechtecks ist "　+　(länge　*　breite));
　　　　}
}
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Rectangle r1　= new Rectangle();
　　　　　　　　r1.getArea(5,　6);
　　　　}
}

Ausgabeergebnis

Der Flächeninhalt eines Rechtecks ist　30

Im obigen Programm wurde eine Schnittstelle Polygon erstellt. Die Schnittstelle Polygon hat den abstrakten Methoden getArea().

　Das bedeutet, dass jede Klasse, die Polygon implementiert, die Implementierung der Methode getArea() bereitstellen muss.

Beachten Sie, dass die Klasse Rectangle (Implementierung von Polygon-Schnittstelle) Methoden mit Implementierung hat, getArea().

Warum Schnittstellen verwenden?

Nun, dass wir wissen, was eine Schnittstelle ist, lassen Sie uns verstehen, warum Schnittstellen in Java verwendet werden.

• Schnittstellen bieten Normen, die die Klasse (die sie implementiert) befolgen muss.

• Im obigen Beispiel haben wir getArea() als Norm in der Schnittstelle Polygon verwendet. Dies ist wie das Setzen einer Regel, dass wir den Flächeninhalt jedes Polygons erhalten sollten. Daher muss jede Klasse, die die Schnittstelle Polygon implementiert, die Implementierung der Methode getArea() bereitstellen.

• Wie bei abstrakten Klassen, können Schnittstellen uns helfen, Java-Abstraktion zu erreichen. Hier wissen wir, dass getArea() den Flächeninhalt des Polygons berechnet, aber für verschiedene Polygone ist der Weg zur Flächenberechnung unterschiedlich. Daher sind die Implementierungen von getArea() unabhängig voneinander.

• Schnittstellen werden auch verwendet, um Mehrfachvererbung in Java zu erreichen. Wenn eine Unterklasse von zwei oder mehr Klassen abgeleitet wird, ist es Mehrfachvererbung.

  In Java kann man keine Mehrfachvererbung durch Vererbung von Klassen erreichen. Aber eine Klasse kann mehrere Schnittstellen implementieren. Dies ermöglicht es uns, die Funktion der Mehrfachvererbung in Java zu erlangen. Zum Beispiel,

  interface Line {
  　　　...
  }
  interface　Polygon　{
  　　　...
  }
  class　Rectangle　implements　Line,　Polygon{
  　　　...
  }

  Hier muss Rectangle die Implementierung aller Methoden von Line und Polygon bereitstellen.

Privater Methoden und statische Methoden in der Schnittstelle

Java 8Daher können Schnittstellen in Java statische Methoden enthalten.

Wie bei Klassen, können wir ihre Referenz verwenden, um auf die statischen Methoden der Schnittstelle zuzugreifen. Zum Beispiel,

Polygon.staticMethod();

Außerdem, Schnittstelle in Java 9Wird in der Ausgabeversion die Unterstützung für Privater Methoden. Jetzt können Sie in der Schnittstelle verwendenPrivater MethodenundPrivater statischer Methoden。

Da Schnittstellen nicht instantiiert werden können, werden private Methoden als Hilfsmethoden verwendet, um anderen Methoden in der Schnittstelle Unterstützung zu bieten.

Standardmethoden in Schnittstellen

Java 8In der Schnittstelle wurden Methoden mit Implementierung (Standardmethoden) eingeführt. Davor waren alle Methoden in Java abstrakte Methoden.

Um eine Standardmethode innerhalb der Schnittstelle zu deklarieren, verwenden wir den Schlüsselwort default. Zum Beispiel,

public default void getSides() {
　　　//Körper von getSides()
}

Warum Standardmethoden verwenden?

Lassen Sie uns mit einer Szene verstehen, warum Java Standardmethoden eingeführt hat.

Angenommen, wir müssen eine neue Methode in die Schnittstelle hinzufügen.

Wir können das Verfahren einfach in die Schnittstelle hinzufügen, ohne es auszuführen. Aber das ist noch nicht das Ende der Geschichte. Alle Klassen, die diesen Schnittstelle implementieren, müssen die Implementierung dieser Methode bereitstellen.

Wenn viele Klassen diesen Schnittstelle implementieren, müssen wir alle diese Klassen verfolgen und ändern. Dies ist nicht nur lästig, sondern auch anfällig für Fehler.

Um dieses Problem zu lösen, hat Java Standardmethoden eingeführt. Standardmethoden werden wie gewöhnliche Methoden vererbt.

Lassen Sie uns mit einem Beispiel besser verstehen, was Standardmethoden sind.

Beispiel2：Standardmethode

interface Polygon {
　　　void getArea();
　　　default void getSides() {
　　　　　　System.out.println("Ich kann die Kanten des Polygons erhalten.");
　　　}
}
class Rectangle implements Polygon {
　　　public void getArea() {
　　　　　　int length =　6;
　　　　　　int breite =　5;
　　　　　　int area = length　*　breite;
　　　　　　System.out.println("Der Flächeninhalt des Rechtecks ist "+area);
　　　}
　　　public void getSides() {
　　　　　　System.out.println("Ich habe vier Seiten.");
　　　}
}
class Square implements Polygon {
　　　public void getArea() {
　　　　　　int length =　5;
　　　　　　int area = length　*　length;
　　　　　　System.out.println("Der Flächeninhalt des Quadrates ist "+area);
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Rectangle r1　= new Rectangle();
　　　　　　r1.getArea();
　　　　　　r1.getSides();
　　　　　　Square s1　= new Square();
　　　　　　s1.getArea();
　　　}
}

Ausgabeergebnis

Der Flächeninhalt eines Rechtecks ist　30
Ich habe vier Seiten.
Der Flächeninhalt eines Quadrates ist　25

Im obigen Beispiel haben wir eine Polygon-Schnittstelle erstellt. Polygon hat eine Standardmethode getSides() und eine abstrakte Methode getArea().

Dann implementiert die Klasse Rectangle die Polygon, Rectangle bietet die Implementierung der abstrakten Methode getArea() und überschreibt die Standardmethode getSides().

Wir haben eine weitere Klasse Square erstellt, die Polygon ebenfalls implementiert. Hier bietet Square nur die Implementierung der abstrakten Methode getArea().

Praktisches Beispiel für die Anwendung der Schnittstelle

Lassen Sie uns ein praktischeres Beispiel für ein Java-Interface sehen.

//Verwendung der sqrt-Funktion
import java.lang.Math;
interface Polygon {
　　　void getArea();
　　
　　　　　//Berechnung des Umfangs des Vielecks
　　　default void getPerimeter(int... sides) {
　　　　　　int perimeter = 0;
　　　　　　for (int side: sides) {
　　　　　　　　　perimeter　+= side;
　　　　　　}
　　　System.out.println("Umfang: "　+　perimeter);
　　　}
}
class Triangle implements Polygon {
　　　private int a, b, c;
　　　private double s, area;
　　　　//Initialisierung der Seiten des Dreiecks
　　　Triangle(int a, int b, int c) {
　　　　　　this.a = a;
　　　　　　this.b = b;
　　　　　　this.c = c;
　　　　　　s = 0;
　　　}
　　　　//Berechnung der Fläche des Dreiecks
　　　public void getArea() {
　　　　　　s = (double) (a　+　b　+　c)/2;
　　　　　　area = Math.sqrt(s*(s-a)*(s-b)*(s-c));
　　　　　　System.out.println("Fläche: "　+　area);
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Triangle t1　= new Triangle(2,　3,　4);
　　　　　　//Aufruf der Methode der Triangle-Klasse
　　　　　　t1.getArea();
　　　　　　//Aufruf der Methode der Polygon-Klasse
　　　　　　t1.getPerimeter(2,　3,　4);
　　　}
}

Ausgabeergebnis

Fläche:　2.9047375096555625
Umfang:　9

Im obigen Programm haben wir eine Schnittstelle Polygon erstellt. Sie umfasst die Standardmethode getParameter() und die abstrakte Methode getArea().

Wir können auf die gleiche Weise den Umfang aller Vielecke berechnen, daher haben wir die Hauptfunktion von getPerimeter() in Polygon implementiert. Daher können alle Vielecke, die Polygon implementieren, den Umfang mit getPerimeter() berechnen.

Die Berechnungsmethode des Flächeninhalts ist jedoch unterschiedlich für verschiedene Vielecke, da die Regeln zur Flächenberechnung für verschiedene Vielecke unterschiedlich sind.

Daher enthält Polygon keine Implementierung und enthält getArea(). Und jede Klasse, die das Polygon-Interface implementiert, muss eine Implementierung von getArea() bereitstellen.

Interface und extends-Schlüsselwort

Wie Klassen können Interfaces auch andere Interfaces inheritten. Der Schlüsselwort "extends" wird verwendet, um Interfaces zu inheritten. Zum Beispiel,

interface Line {
　　　//Mitglied von Line-Interface
}
interface Polygon extends Line {
　　　//Mitglied von Polygon- und Line-Interface
}

Im obigen Beispiel erweitert das Interface Polygon das Interface Line. Wenn eine Klasse Polygon implementiert, sollte sie alle abstrakten Klassen von Line und Polygon implementieren.

Beachten Sie, dass ein Interface mehrere Interfaces inheritten kann, ähnlich wie eine Klasse, die mehrere Interfaces implementiert. Zum Beispiel,

interface A {
　　　...
}
interface B {
　　　...　
}
Interface C extends A, B {
　　　...
}