Java-Schnittstelle

Java-Oberfläche

In diesem Tutorial lernen wir Java-Schnittstellen kennen. Anhand von Beispielen lernen wir ausführlich, wie Schnittstellen implementiert und wann sie eingesetzt werden.

Eine Schnittstelle ist eine vollständig abstrakte Klasse. Es enthält eine Gruppe abstrakter Methoden (Methoden ohne Körper).

Wir verwenden den interface Schlüsselwort zum Erstellen einer Schnittstelle in Java. Zum Beispiel

interface Language {
  public void getType();

  public void getVersion();
}

Hier,

Sprache ist eine Schnittstelle.
Enthält abstrakte Methoden:getType() und getVersion() .

Eine Schnittstelle implementieren

Wie abstrakte Klassen können wir keine Objekte von Schnittstellen erstellen.

Um eine Schnittstelle zu verwenden, müssen andere Klassen sie implementieren. Wir verwenden den implements Schlüsselwort zum Implementieren einer Schnittstelle.

Beispiel 1:Java-Schnittstelle

interface Polygon {
  void getArea(int length, int breadth);
}

// implement the Polygon interface
class Rectangle implements Polygon {

  // implementation of abstract method
  public void getArea(int length, int breadth) {
    System.out.println("The area of the rectangle is " + (length * breadth));
  }
}

class Main {
  public static void main(String[] args) {
    Rectangle r1 = new Rectangle();
    r1.getArea(5, 6);
  }
}

Ausgabe

The area of the rectangle is 30

Im obigen Beispiel haben wir eine Schnittstelle namens Polygon erstellt . Die Schnittstelle enthält eine abstrakte Methode getArea() .

Hier das Rechteck Klasse implementiert Polygon . Und stellt die Implementierung von getArea() bereit Methode.

Beispiel 2:Java-Schnittstelle

// create an interface
interface Language {
  void getName(String name);
}

// class implements interface
class ProgrammingLanguage implements Language {

  // implementation of abstract method
  public void getName(String name) {
    System.out.println("Programming Language: " + name);
  }
}

class Main {
  public static void main(String[] args) {
    ProgrammingLanguage language = new ProgrammingLanguage();
    language.getName("Java");
  }
}

Ausgabe

Programming Language: Java

Im obigen Beispiel haben wir eine Schnittstelle namens Language erstellt . Die Schnittstelle enthält eine abstrakte Methode getName() .

Hier die ProgrammingLanguage Klasse implementiert die Schnittstelle und stellt die Implementierung für die Methode bereit.

Mehrere Schnittstellen implementieren

In Java kann eine Klasse auch mehrere Interfaces implementieren. Zum Beispiel

interface A {
  // members of A
}

interface B {
  // members of B
}

class C implements A, B {
  // abstract members of A
  // abstract members of B
}

Eine Schnittstelle erweitern

Ähnlich wie Klassen können Interfaces andere Interfaces erweitern. Die extends Das Schlüsselwort wird zum Erweitern von Schnittstellen verwendet. Zum Beispiel

interface Line {
  // members of Line interface
}

// extending interface
interface Polygon extends Line {
  // members of Polygon interface
  // members of Line interface
}

Hier das Polygon Schnittstelle erweitert die Zeile Schnittstelle. Wenn nun irgendeine Klasse Polygon implementiert , sollte es Implementierungen für alle abstrakten Methoden von beiden Line bereitstellen und Polygon .

Mehrere Schnittstellen erweitern

Eine Schnittstelle kann mehrere Schnittstellen erweitern. Zum Beispiel

interface A {
   ...
}
interface B {
   ... 
}

interface C extends A, B {
   ...
}

Vorteile der Schnittstelle in Java

Nachdem wir nun wissen, was Schnittstellen sind, lernen wir, warum Schnittstellen in Java verwendet werden.

Ähnlich wie abstrakte Klassen helfen uns Schnittstellen, Abstraktion in Java zu erreichen .

Hier kennen wir getArea() berechnet die Fläche von Polygonen, aber die Art und Weise, wie die Fläche berechnet wird, ist für verschiedene Polygone unterschiedlich. Daher die Implementierung von getArea() ist voneinander unabhängig.
Schnittstellen liefern Spezifikationen dass eine Klasse (die es implementiert) folgen muss.

In unserem vorherigen Beispiel haben wir getArea() verwendet als Spezifikation innerhalb der Schnittstelle Polygon . Das ist wie das Aufstellen einer Regel, dass wir in der Lage sein sollten, die Fläche jedes Polygons zu erhalten.

Jetzt jede Klasse, die das Polygon implementiert Schnittstelle muss eine Implementierung für getArea() bereitstellen Methode.
Schnittstellen werden auch verwendet, um Mehrfachvererbung in Java zu erreichen. Zum Beispiel,
```
interface Line {
…
}

interface Polygon {
…
}

class Rectangle implements Line, Polygon {
…
}
```
Hier die Klasse Rectangle implementiert zwei verschiedene Schnittstellen. So erreichen wir Mehrfachvererbung in Java.

Hinweis :Alle Methoden innerhalb einer Schnittstelle sind implizit public und alle Felder sind implizit public static final . Zum Beispiel

interface Language {
  
  // by default public static final
  String type = "programming language";

  // by default public
  void getName();
}

Standardmethoden in Java-Schnittstellen

Mit der Veröffentlichung von Java 8 können wir jetzt Methoden mit Implementierung innerhalb einer Schnittstelle hinzufügen. Diese Methoden werden Standardmethoden genannt.

Um Standardmethoden innerhalb von Schnittstellen zu deklarieren, verwenden wir den default Stichwort. Zum Beispiel

public default void getSides() {
   // body of getSides()
}

Warum Standardmethoden?

Sehen wir uns ein Szenario an, um zu verstehen, warum Standardmethoden in Java eingeführt werden.

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

Wir können die Methode einfach ohne Implementierung in unsere Schnittstelle einfügen. Das ist jedoch noch nicht das Ende der Geschichte. Alle unsere Klassen, die diese Schnittstelle implementieren, müssen eine Implementierung für die Methode bereitstellen.

Wenn eine große Anzahl von Klassen diese Schnittstelle implementiert, müssen wir alle diese Klassen verfolgen und Änderungen an ihnen vornehmen. Das ist nicht nur mühsam, sondern auch fehleranfällig.

Um dies zu beheben, hat Java Standardmethoden eingeführt. Standardmethoden werden wie gewöhnliche Methoden vererbt.

Nehmen wir ein Beispiel, um die Standardmethoden besser zu verstehen.

Beispiel:Standardmethode in der Java-Oberfläche

interface Polygon {
  void getArea();

  // default method 
  default void getSides() {
    System.out.println("I can get sides of a polygon.");
  }
}

// implements the interface
class Rectangle implements Polygon {
  public void getArea() {
    int length = 6;
    int breadth = 5;
    int area = length * breadth;
    System.out.println("The area of the rectangle is " + area);
  }

  // overrides the getSides()
  public void getSides() {
    System.out.println("I have 4 sides.");
  }
}

// implements the interface
class Square implements Polygon {
  public void getArea() {
    int length = 5;
    int area = length * length;
    System.out.println("The area of the square is " + area);
  }
}

class Main {
  public static void main(String[] args) {

    // create an object of Rectangle
    Rectangle r1 = new Rectangle();
    r1.getArea();
    r1.getSides();

    // create an object of Square
    Square s1 = new Square();
    s1.getArea();
    s1.getSides();
  }
}

Ausgabe

The area of the rectangle is 30
I have 4 sides.
The area of the square is 25
I can get sides of a polygon.

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

Hier haben wir zwei Klassen Rectangle erstellt und Quadrat die Polygon implementieren .

Das Rechteck Klasse stellt die Implementierung von getArea() bereit -Methode und überschreibt den getSides() Methode. Aber das Quadrat Klasse stellt nur die Implementierung von getArea() bereit Methode.

Jetzt beim Aufrufen der getSides() Methode mit dem Rectangle -Objekt wird die überschriebene Methode aufgerufen. Im Fall von Square jedoch Objekt wird die Standardmethode aufgerufen.

private und statische Methoden in der Schnittstelle

Java 8 hat auch eine weitere Funktion hinzugefügt, um statische Methoden in eine Schnittstelle aufzunehmen.

Ähnlich wie bei einer Klasse können wir über ihre Referenzen auf statische Methoden einer Schnittstelle zugreifen. Zum Beispiel

// create an interface
interface Polygon {
  staticMethod(){..}
}

// access static method
Polygon.staticMethod();

Hinweis :Mit der Veröffentlichung von Java 9 werden auch private Methoden in Schnittstellen unterstützt.

Wir können keine Objekte einer Schnittstelle erstellen. Daher werden private Methoden als Hilfsmethoden verwendet, die andere Methoden in Schnittstellen unterstützen.

Praxisbeispiel für Schnittstelle

Sehen wir uns ein praktischeres Beispiel der Java-Schnittstelle an.

// To use the sqrt function
import java.lang.Math;

interface  Polygon {
   void getArea();
  
 // calculate the perimeter of a Polygon
   default void getPerimeter(int... sides) {
      int perimeter = 0;
      for (int side: sides) {
         perimeter += side;
      }

   System.out.println("Perimeter: " + perimeter);
   }
}

class Triangle implements Polygon {
   private int a, b, c;
   private double s, area;

// initializing sides of a triangle
   Triangle(int a, int b, int c) {
      this.a = a;
      this.b = b;
      this.c = c;
      s = 0;
   }

// calculate the area of a triangle
   public void getArea() {
      s = (double) (a + b + c)/2;
      area = Math.sqrt(s*(s-a)*(s-b)*(s-c));
      System.out.println("Area: " + area);
   }
}

class Main {
   public static void main(String[] args) {
      Triangle t1 = new Triangle(2, 3, 4);

// calls the method of the Triangle class
      t1.getArea();

// calls the method of Polygon
      t1.getPerimeter(2, 3, 4);
   }
}

Ausgabe

Area: 2.9047375096555625
Perimeter: 9

Im obigen Programm haben wir eine Schnittstelle namens Polygon erstellt . Es enthält eine Standardmethode getPerimeter() und eine abstrakte Methode getArea() .

Wir können den Umfang aller Polygone auf die gleiche Weise berechnen, also haben wir den Körper von getPerimeter() implementiert im Polygon .

Jetzt alle Polygone, die Polygon implementieren kann getPerimeter() verwenden um den Umfang zu berechnen.

Die Regel zur Berechnung der Fläche ist jedoch für verschiedene Polygone unterschiedlich. Daher getArea() ist ohne Implementierung enthalten.

Jede Klasse, die Polygon implementiert muss eine Implementierung von getArea() bereitstellen .

Abstrakte Java-Klasse und abstrakte Methoden Java-Polymorphismus

Java