Ein Schnittstelle in Java Programmiersprache ist als abstrakter Typ definiert, der zur Angabe des Verhaltens einer Klasse verwendet wird. Eine Schnittstelle in Java ist ein Entwurf eines Verhaltens. Eine Java-Schnittstelle enthält statische Konstanten und abstrakte Methoden.

Was sind Schnittstellen in Java?

Die Schnittstelle in Java ist A Mechanismus zu erreichen Abstraktion . In der Java-Schnittstelle können nur abstrakte Methoden vorhanden sein, nicht der Methodenkörper. Es wird verwendet, um Abstraktion zu erreichen und Mehrfachvererbungen in Java mithilfe der Schnittstelle . Mit anderen Worten kann man sagen, dass Schnittstellen abstrakte Methoden und Variablen haben können. Es kann keinen Methodenkörper haben. Java-Schnittstelle auch stellt die IS-A-Beziehung dar .

Java hasnext

Wenn wir uns für einen Entitätstyp anhand seines Verhaltens und nicht anhand eines Attributs entscheiden, sollten wir ihn als Schnittstelle definieren.

Syntax für Java-Schnittstellen

interface {  // declare constant fields  // declare methods that abstract   // by default.  }>

Um eine Schnittstelle zu deklarieren, verwenden Sie das Schlüsselwort interface. Es wird verwendet, um eine vollständige Abstraktion bereitzustellen. Das bedeutet, dass alle Methoden in einer Schnittstelle mit einem leeren Textkörper deklariert werden und öffentlich sind und alle Felder standardmäßig öffentlich, statisch und endgültig sind. Eine Klasse, die eine Schnittstelle implementiert, muss alle in der Schnittstelle deklarierten Methoden implementieren. Um die Schnittstelle zu implementieren, verwenden Sie das Schlüsselwort „implements“.

Verwendung von Schnittstellen in Java

Nachfolgend werden die Verwendungsmöglichkeiten von Schnittstellen in Java aufgeführt:

• Es wird verwendet, um eine vollständige Abstraktion zu erreichen.
• Da Java im Fall einer Klasse keine Mehrfachvererbung unterstützt, kann es durch die Verwendung einer Schnittstelle eine Mehrfachvererbung erreichen.
• Jede Klasse kann nur eine Klasse erweitern, aber jede Klasse kann eine unendliche Anzahl von Schnittstellen implementieren.
• Es wird auch verwendet, um eine lose Kopplung zu erreichen.
• Zur Implementierung der Abstraktion werden Schnittstellen verwendet.

Es stellt sich also die Frage, warum Schnittstellen verwendet werden, wenn es abstrakte Klassen gibt?

Der Grund dafür ist, dass abstrakte Klassen möglicherweise nicht endgültige Variablen enthalten, während Variablen in der Schnittstelle endgültig, öffentlich und statisch sind.

// A simple interface interface Player {  final int id = 10;  int move(); }>

Beziehung zwischen Klasse und Schnittstelle

Eine Klasse kann eine andere Klasse erweitern, ähnlich wie eine Schnittstelle eine andere Schnittstelle erweitern kann. Es kann jedoch nur eine Klasse auf eine andere Schnittstelle erweitert werden, und umgekehrt ist dies nicht zulässig.

Unterschied zwischen Klasse und Schnittstelle

Obwohl Klasse und Schnittstelle gleich zu sein scheinen, gibt es gewisse Unterschiede zwischen Klassen und Schnittstelle. Die Hauptunterschiede zwischen einer Klasse und einer Schnittstelle werden im Folgenden aufgeführt:

Implementierung: Um eine Schnittstelle zu implementieren, verwenden wir das Schlüsselwort implementiert

// Java program to demonstrate working of // interface import java.io.*; // A simple interface interface In1 {    // public, static and final  final int a = 10;  // public and abstract  void display(); } // A class that implements the interface. class TestClass implements In1 {    // Implementing the capabilities of  // interface.  public void display(){   System.out.println('Geek');   }  // Driver Code  public static void main(String[] args)  {  TestClass t = new TestClass();  t.display();  System.out.println(t.a);  } }>

Geek 10>

Beispiele für Java-Schnittstellen

Betrachten wir das Beispiel von Fahrzeugen wie Fahrrädern, Autos, Fahrrädern usw., die gemeinsame Funktionen haben. Also erstellen wir eine Schnittstelle und integrieren all diese gemeinsamen Funktionalitäten. Und lässt Bicycle, Bike, Car usw. alle diese Funktionalitäten in ihrer eigenen Klasse auf ihre eigene Weise implementieren.

Nachfolgend finden Sie die Umsetzung des oben genannten Themas:

Sammlungen in Java

// Java program to demonstrate the  // real-world example of Interfaces import java.io.*; interface Vehicle {    // all are the abstract methods.  void changeGear(int a);  void speedUp(int a);  void applyBrakes(int a); } class Bicycle implements Vehicle{    int speed;  int gear;    // to change gear  @Override  public void changeGear(int newGear){    gear = newGear;  }    // to increase speed  @Override  public void speedUp(int increment){    speed = speed + increment;  }    // to decrease speed  @Override  public void applyBrakes(int decrement){    speed = speed - decrement;  }    public void printStates() {  System.out.println('speed: ' + speed  + ' gear: ' + gear);  } } class Bike implements Vehicle {    int speed;  int gear;    // to change gear  @Override  public void changeGear(int newGear){    gear = newGear;  }    // to increase speed  @Override  public void speedUp(int increment){    speed = speed + increment;  }    // to decrease speed  @Override  public void applyBrakes(int decrement){    speed = speed - decrement;  }    public void printStates() {  System.out.println('speed: ' + speed  + ' gear: ' + gear);  }   } class GFG {    public static void main (String[] args) {    // creating an instance of Bicycle  // doing some operations  Bicycle bicycle = new Bicycle();  bicycle.changeGear(2);  bicycle.speedUp(3);  bicycle.applyBrakes(1);    System.out.println('Bicycle present state :');  bicycle.printStates();    // creating instance of the bike.  Bike bike = new Bike();  bike.changeGear(1);  bike.speedUp(4);  bike.applyBrakes(3);    System.out.println('Bike present state :');  bike.printStates();  } }>

Bicycle present state : speed: 2 gear: 2 Bike present state : speed: 1 gear: 1>

Vorteile von Schnittstellen in Java

Die Vorteile der Verwendung von Schnittstellen in Java sind folgende:

• Ohne uns um den Implementierungsteil zu kümmern, können wir die Sicherheit der Implementierung erreichen.
• In Java sind Mehrfachvererbungen nicht zulässig. Sie können jedoch eine Schnittstelle verwenden, um davon Gebrauch zu machen, da Sie mehr als eine Schnittstelle implementieren können.

Mehrfachvererbung in Java mithilfe der Schnittstelle

Mehrfachvererbung ist ein OOPs-Konzept, das in Java nicht mithilfe von Klassen implementiert werden kann. Aber wir können in Java mithilfe von Interface mehrere Vererbungen verwenden. Lassen Sie uns dies anhand eines Beispiels überprüfen.

Konvertieren Sie die Zeichenfolge in ein Datum

Beispiel:

// Java program to demonstrate How Diamond Problem // Is Handled in case of Default Methods // Interface 1 interface API {  // Default method  default void show()  {  // Print statement  System.out.println('Default API');  } } // Interface 2 // Extending the above interface interface Interface1 extends API {  // Abstract method  void display(); } // Interface 3 // Extending the above interface interface Interface2 extends API {  // Abstract method  void print(); } // Main class // Implementation class code class TestClass implements Interface1, Interface2 {  // Overriding the abstract method from Interface1  public void display()  {  System.out.println('Display from Interface1');  }  // Overriding the abstract method from Interface2  public void print()  {  System.out.println('Print from Interface2');  }  // Main driver method  public static void main(String args[])  {  // Creating object of this class  // in main() method  TestClass d = new TestClass();  // Now calling the methods from both the interfaces  d.show(); // Default method from API  d.display(); // Overridden method from Interface1  d.print(); // Overridden method from Interface2  } }>

Default API>

Neue Funktionen in den Schnittstellen in JDK 8 hinzugefügt

Im JDK 8-Update wurden bestimmte Funktionen zu den Schnittstellen hinzugefügt, die unten erwähnt werden:

1. Vor JDK 8 konnte die Schnittstelle die Implementierung nicht definieren. Wir können jetzt eine Standardimplementierung für Schnittstellenmethoden hinzufügen. Diese Standardimplementierung hat einen besonderen Zweck und hat keinen Einfluss auf die Absicht hinter Schnittstellen.

Angenommen, wir müssen einer vorhandenen Schnittstelle eine neue Funktion hinzufügen. Offensichtlich wird der alte Code nicht funktionieren, da die Klassen diese neuen Funktionen nicht implementiert haben. Mit Hilfe der Standardimplementierung werden wir also einen Standardkörper für die neu hinzugefügten Funktionen bereitstellen. Dann funktionieren die alten Codes weiterhin.

Nachfolgend finden Sie die Umsetzung des obigen Punktes:

// Java program to show that interfaces can // have methods from JDK 1.8 onwards interface In1 {  final int a = 10;  default void display()  {  System.out.println('hello');  } } // A class that implements the interface. class TestClass implements In1 {  // Driver Code  public static void main (String[] args)  {  TestClass t = new TestClass();  t.display();  } }>

hello>

2. Eine weitere Funktion, die in JDK 8 hinzugefügt wurde, besteht darin, dass wir jetzt statische Methoden in Schnittstellen definieren können, die unabhängig ohne Objekt aufgerufen werden können.

Notiz: Diese Methoden werden nicht vererbt.

// Java Program to show that interfaces can // have methods from JDK 1.8 onwards interface In1 {  final int a = 10;  static void display()  {  System.out.println('hello');  } } // A class that implements the interface. class TestClass implements In1 {  // Driver Code  public static void main (String[] args)  {  In1.display();  } }>

hello>

Schnittstellen erweitern

Mithilfe des Schlüsselworts „extends“ kann eine Schnittstelle eine andere erben. Wenn eine Klasse eine Schnittstelle implementiert, die eine andere Schnittstelle erbt, muss sie eine Implementierung für alle Methoden bereitstellen, die für die Schnittstellenvererbungskette erforderlich sind.

Programm 1:

So generieren Sie eine Zufallszahl in Java

interface A {  void method1();  void method2(); } // B now includes method1 and method2 interface B extends A {  void method3(); } // the class must implement all method of A and B. class gfg implements B {  public void method1()  {  System.out.println('Method 1');  }  public void method2()  {  System.out.println('Method 2');  }  public void method3()  {  System.out.println('Method 3');  } }>

Programm 2:

interface Student  {  public void data();   } class avi implements Student {  public void data ()  {  String name='avinash';  int rollno=68;  System.out.println(name);  System.out.println(rollno);  } } public class inter_face  {  public static void main (String args [])  {  avi h= new avi();  h.data();  } }>

avinash 68>

Auf einfache Weise enthält die Schnittstelle mehrere abstrakte Methoden, also schreiben Sie die Implementierung in Implementierungsklassen. Wenn die Implementierung nicht in der Lage ist, eine Implementierung aller abstrakten Methoden bereitzustellen, deklarieren Sie die Implementierungsklasse mit einem abstrakten Modifikator und schließen Sie die verbleibende Methodenimplementierung in den nächsten erstellten untergeordneten Klassen ab. Es ist möglich, mehrere untergeordnete Klassen zu deklarieren, aber letztendlich haben wir die Implementierung aller abstrakten Methoden abgeschlossen.

Generell verläuft der Entwicklungsprozess Schritt für Schritt:

Level 1 – Schnittstellen: Enthält die Servicedetails.
Level 2 – abstrakte Klassen: Sie enthalten eine teilweise Implementierung.
Stufe 3 – Implementierungsklassen: Es enthält alle Implementierungen.
Level 4 – Endgültiger Code / Hauptmethode: Sie hat Zugriff auf alle Schnittstellendaten.

Beispiel:

// Java Program for // implementation Level wise import java.io.*; import java.lang.*; import java.util.*; // Level 1 interface Bank {  void deposit();  void withdraw();  void loan();  void account(); } // Level 2 abstract class Dev1 implements Bank {  public void deposit()  {  System.out.println('Your deposit Amount :' + 100);  } } abstract class Dev2 extends Dev1 {  public void withdraw()  {  System.out.println('Your withdraw Amount :' + 50);  } } // Level 3 class Dev3 extends Dev2 {  public void loan() {}  public void account() {} } // Level 4 class GFG {  public static void main(String[] args)  {  Dev3 d = new Dev3();  d.account();  d.loan();  d.deposit();  d.withdraw();  } }>

Your deposit Amount :100 Your withdraw Amount :50>

Neue Funktionen in den Schnittstellen in JDK 9 hinzugefügt

Ab Java 9 können Schnittstellen auch Folgendes enthalten:

1. Statische Methoden
2. Private Methoden
3. Private statische Methoden

Wichtige Punkte in Java-Schnittstellen

In dem Artikel erfahren wir einige wichtige Punkte zu Schnittstellen, wie unten erwähnt:

• Wir können keine Instanz der Schnittstelle erstellen (die Schnittstelle kann nicht instanziiert werden), aber wir können eine Referenz davon erstellen, die auf das Objekt ihrer implementierenden Klasse verweist.
• Eine Klasse kann mehr als eine Schnittstelle implementieren.
• Eine Schnittstelle kann sich auf eine andere Schnittstelle oder Schnittstelle (mehr als eine Schnittstelle) erstrecken.
• Eine Klasse, die die Schnittstelle implementiert, muss alle Methoden in der Schnittstelle implementieren.
• Alle Methoden sind öffentlich und abstrakt. Und alle Felder sind öffentlich, statisch und endgültig.
• Es wird verwendet, um Mehrfachvererbungen zu erreichen.
• Es wird verwendet, um eine lose Kopplung zu erreichen.
• Innerhalb der Schnittstelle ist es nicht möglich, Instanzvariablen zu deklarieren, da dies standardmäßig bei Variablen der Fall ist öffentliches statisches Finale.
• Innerhalb der Schnittstelle sind Konstruktoren nicht zulässig.
• Innerhalb der Schnittstelle ist die Hauptmethode nicht zulässig.
• Innerhalb der Schnittstelle sind keine statischen, endgültigen und privaten Methodendeklarationen möglich.

Muss lesen

• Zugriffsspezifizierer von Methoden in Schnittstellen
• Zugriffsspezifizierer für Klassen oder Schnittstellen in Java
• Abstrakte Klassen in Java
• Komparatorschnittstelle in Java
• Java-Schnittstellenmethoden
• Verschachtelte Schnittstelle in Java

Häufig gestellte Fragen zu Schnittstellen

1. Was ist eine Marker- oder getaggte Schnittstelle?

Mit Tags versehene Schnittstellen sind Schnittstellen ohne Methoden, die als Markierung ohne Fähigkeiten dienen.

Prioritätswarteschlange Java

2. Wie viele Arten von Schnittstellen gibt es in Java?

Im Folgenden werden die Schnittstellentypen in Java aufgeführt:

1. Funktionsschnittstelle
2. Marker-Schnittstelle

3. Warum wird die Mehrfachvererbung durch Klassen in Java nicht unterstützt?

Mehrfachvererbung wird in Java nicht durch Klassen unterstützt, um bestimmte Herausforderungen wie Mehrdeutigkeit und Rautenprobleme zu vermeiden.