Menü

Java Interface und Abstract Class Tutorial mit Beispielen

  • Haupt
  • Andere
  • Java Interface und Abstract Class Tutorial mit Beispielen

java interface abstract class tutorial with examples

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

In diesem Video-Tutorial wird anhand von Beispielen erläutert, was Java-Schnittstelle ist, wie sie implementiert wird und wie sie mithilfe von Schnittstellen in Java mehrfach vererbt wird:

In einem unserer früheren Tutorials haben wir die Abstraktion ausführlich besprochen. Dort diskutierten wir abstrakte Klassen und abstrakte Methoden. Wir wissen, dass abstrakte Klassen Abstraktion bieten, da wir auch eine nicht abstrakte Methode in der abstrakten Klasse haben können.

Die Funktion, die in Java eine 100% ige Abstraktion bietet, heißt „ Schnittstelle ”. In diesem Tutorial werden wir diskutieren Schnittstellen in Java.

=> Schauen Sie sich hier den Java Beginners Guide an.

Java-Schnittstellen und abstrakte Klassen

Was du lernen wirst:

Video-Tutorials zu Schnittstellen und abstrakten Klassen

Einführung in Schnittstellen und abstrakte Klassen in Java - Teil 1:

Übersicht über Schnittstellen und abstrakte Klassen in Java - Teil 2:

Abstraktion und Vererbung in Java:

Was ist eine Schnittstelle in Java?

Eine Schnittstelle in Java ist als abstrakter Typ definiert, der das Klassenverhalten angibt. Eine Schnittstelle ist eine Art Protokoll, das Regeln für das Verhalten einer bestimmten Klasse festlegt.

Eine Schnittstelle in Java kann abstrakte Methoden und statische Konstanten enthalten. Standardmäßig sind alle Methoden in der Schnittstelle öffentlich und abstrakt.

Ein einfaches Beispiel für eine Schnittstelle in Java ist unten angegeben.

interface shape{ public static final String color = “Red”; public void calculateArea(); }

Das obige Beispiel definiert eine Schnittstelle 'Form' mit einer statischen Variablen und einer abstrakten Methode 'berechneArea ()'.

Eine Schnittstelle ist eine Entität, deren Körper nur abstrakte Methoden enthält. Es kann auch statische Endvariablen enthalten.

Genau wie eine Klasse kann eine Schnittstelle auch Methoden und Variablen enthalten. Beachten Sie jedoch, dass die Methoden abstrakt (ohne Implementierung) und die Variablen statisch sind.

Nachfolgend sind einige Eigenschaften aufgeführt, die im Zusammenhang mit Schnittstellen beachtet werden sollten:

  • Schnittstellen sind Blaupausen für eine Klasse. Sie sagen der Klasse, was sie mit ihren Methoden tun soll.
  • Eine Schnittstelle gibt abstrakte Methoden an, und Klassen, die diese Schnittstelle implementieren, sollten auch diese Methoden implementieren.
  • Wenn eine Klasse, die die Schnittstelle implementiert, nicht alle Methoden der Schnittstelle definiert, wird diese Klasse zu einer abstrakten Klasse.

Die allgemeine Syntax der Schnittstellendeklaration ist unten angegeben.

interface { //constant or static fields declaration //abstract method declaration //default declarations }

Wie in der obigen Deklaration gezeigt, verwenden wir ein Java-Schlüsselwort 'interface', das angibt, dass wir jetzt eine Schnittstelle deklarieren.

Fragen und Antworten zu Qualitätssicherungstests

Auf ein Schlüsselwort 'interface' folgen der Name 'interface_name' und dann die öffnenden geschweiften Klammern. Dann haben wir verschiedene Deklarationen von abstrakten Methoden, statischen Felddeklarationen usw. Schließlich schließen wir die geschweiften Klammern.

Zum Beispiel,Wenn wir eine Schnittstelle 'TestInterface' mit zwei Methoden deklarieren möchten, d. h. method_one und method_two, lautet die Deklaration von TestInterface wie folgt:

interface TestInterface{ void method_one(); void method_two(); }

Verwendung der Schnittstelle in Java

  • Schnittstellen in Java bieten eine 100% ige Abstraktion, da sie nur abstrakte Methoden haben können.
  • Mithilfe von Schnittstellen können wir in Java mehrere Vererbungen erzielen, die mit Klassen nicht möglich sind.
  • Um eine lose Kopplung zu erreichen, kann eine Schnittstelle verwendet werden.

So implementieren Sie eine Schnittstelle in Java

Sobald die Schnittstelle deklariert ist, können wir sie in einer Klasse verwenden Verwenden Sie das Schlüsselwort 'implementiert' in der Klassendeklaration.

Dieses Schlüsselwort 'implementiert' wird nach dem Klassennamen wie folgt angezeigt:

class implements { //class body }

Das Implementieren einer Schnittstelle entspricht dem Unterzeichnen eines Vertrags. Eine Klasse, die eine Schnittstelle implementiert, bedeutet daher, dass sie einen Vertrag unterzeichnet und sich bereit erklärt hat, die abstrakten Methoden der Schnittstelle zu implementieren oder mit anderen Worten das von der Schnittstelle angegebene Verhalten auszuführen.

Wenn die Klasse, die die Schnittstelle implementiert, nicht das genaue Verhalten implementiert, das in der Schnittstelle angegeben ist, muss die Klasse als abstrakt deklariert werden.

Beispiel für die Implementierung der Schnittstelle

Im Folgenden finden Sie ein einfaches Beispiel für eine Schnittstelle in Java.

//interface declaration interface Polygon_Shape { void calculateArea(int length, int breadth); } //implement the interface class Rectangle implements Polygon_Shape { //implement the interface method public void calculateArea(int length, int breadth) { System.out.println('The area of the rectangle is ' + (length * breadth)); } } class Main { public static void main(String() args) { Rectangle rect = new Rectangle(); //declare a class object rect.calculateArea(10, 20); //call the method } }

Ausgabe:

Beispielausgabe des Bereichs des Rechtecks

Das obige Programm zeigt das einfache Beispiel von Schnittstellen in Java. Hier deklarieren wir eine Schnittstelle mit dem Namen Polygon_Shape und dann implementiert die Klasse Rectangle sie.

Namenskonvention für Schnittstellen in Java

Java-Namenskonventionen sind die Namensrichtlinien, die wir als Programmierer befolgen müssen, damit wir lesbaren konsistenten Code erstellen können. Java verwendet 'TitleCase' -Notationen für die Namensklassen und Schnittstellen. Es verwendet 'CamelCase' -Notationen für Variablen, Methoden usw.

In Bezug auf die Schnittstelle befindet sich der Schnittstellenname im Titel, wobei der erste Buchstabe jedes Wortes des Schnittstellennamens groß geschrieben wird. Schnittstellennamen werden so ausgewählt, dass sie normalerweise Adjektive sind. Wenn Schnittstellen jedoch die Klassenfamilie wie Map oder List darstellen, können sie nach Substantiven benannt werden.

Einige Beispiele für gültige Schnittstellennamen sind unten angegeben:

public interface Iterable {} public interface List {} public interface Serializable {} public interface Clonable {} public interface Runnable {}

Schnittstellenkonstruktor

Die nächste Frage ist, ob eine Schnittstelle einen Konstruktor hat.

Wir wissen, dass wir Objekte benötigen, um Methoden aufzurufen. Um Objekte zu erstellen, benötigen wir Konstruktoren. Bei Schnittstellen in Java sind die Methoden jedoch nicht implementiert.

Die Methoden der Schnittstellen sind alle abstrakt. Daher ist es sinnlos, diese Methoden über die Schnittstelle aufzurufen. Zweitens können wir keine Objekte der Schnittstelle erstellen, da Schnittstellen standardmäßig abstrakt sind. Daher benötigen wir keine Konstruktoren für Interface.

Schnittstellenmethoden

In diesem Abschnitt wird erläutert, wie Schnittstellenmethoden deklariert werden. In der Regel kann eine Schnittstelle nur öffentliche Methoden haben, oder standardmäßig sind Schnittstellenmethoden öffentlich. Innerhalb der Schnittstelle darf kein anderer Zugriffsmodifikator verwendet werden.

Unabhängig davon, ob wir es explizit deklarieren oder nicht, ist jede Methode in der Schnittstelle standardmäßig abstrakt und öffentlich sichtbar.

Wenn void printMethod () der Prototyp ist, den wir in einer Schnittstelle deklarieren möchten, sind die folgenden Deklarationen identisch.

void printMethod(); public void printMethod(); abstract void printMethod (); public abstract void printMethod ();

Beachten Sie, dass wir die folgenden Modifikatoren in der Schnittstelle nicht für die Schnittstellenmethoden verwenden können.

  • Finale
  • statisch
  • Privat
  • geschützt
  • synchronisiert
  • einheimisch
  • strictfp

Implementieren wir nun ein Java-Programm, um die Sichtbarkeit der Schnittstellenmethode zu demonstrieren.

//declare an interface interface TestInterface { void printMethod(); //default visibility is public. } //interface implementation class TestClass implements TestInterface { //if the access modifier is changed to any other, compiler generates error public void printMethod() { System.out.println('TestClass::printMethod()'); } } class Main { public static void main(String() args) { TestClass tc = new TestClass(); //create an object tc.printMethod(); //call concrete method } }

Ausgabe:

TestClass printMethod

Wie bereits erwähnt, sind die Schnittstellenmethoden standardmäßig öffentlich. Wenn wir also keinen Zugriffsmodifikator für die Schnittstellenmethode angeben, ist dieser wie im obigen Programm öffentlich.

Angenommen, wir ändern die Deklaration der Schnittstellenmethode im obigen Programm wie folgt:

private void printMethod ();

Dies bedeutet dann, dass wir die Schnittstellenmethode printMethod () als privat angegeben haben. Wenn wir das Programm kompilieren, erhalten wir den folgenden Compilerfehler.

Fehler: Modifikator privat hier nicht erlaubt

private void printMethod ();

Der zweite Fall, den wir testen können, besteht darin, den Modifikator der implementierten Methode in der Klasse TestClass von public in private zu ändern. Jetzt ist der Standardmodifikator in der Klasse privat. Daher entfernen wir das öffentliche Schlüsselwort einfach wie folgt aus dem Methodenprototyp in der Klasse:

void printMethod() { System.out.println('TestClass::printMethod()'); }

Wenn wir nun das Programm kompilieren, erhalten wir den folgenden Fehler.

Fehler: printMethod () in TestClass kann printMethod () in TestInterface nicht implementieren
void printMethod ()
^
Versuch, schwächere Zugriffsrechte zuzuweisen; war öffentlich

Daher ist hier zu beachten, dass wir den Zugriffsmodifikator der implementierten Methode der Schnittstelle nicht in einen anderen Zugriffsmodifikator ändern können. Da die Schnittstellenmethoden standardmäßig öffentlich sind, sollten diese Methoden auch öffentlich sein, wenn sie von Klassen implementiert werden, die Schnittstellen implementieren.

Schnittstellenfelder in Java

Die in einer Schnittstelle deklarierten Felder oder Variablen sind standardmäßig öffentlich, statisch und endgültig. Dies bedeutet, dass ihr einmal deklarierter Wert nicht mehr geändert werden kann.

Beachten Sie, dass Java-Compiler diese Modifikatoren übernehmen, wenn die Schnittstellenfelder ohne Angabe eines dieser Modifikatoren definiert werden. Zum Beispiel, Wenn wir beim Deklarieren des Felds in der Schnittstelle keinen öffentlichen Modifikator angeben, wird dies standardmäßig angenommen.

Wenn eine Schnittstelle von einer Klasse implementiert wird, bietet sie eine Implementierung für alle abstrakten Methoden der Schnittstelle. In ähnlicher Weise werden alle in der Schnittstelle deklarierten Felder auch von der Klasse geerbt, die die Schnittstelle implementiert. Somit ist eine Kopie des Schnittstellenfeldes in der implementierenden Klasse vorhanden.

Jetzt sind alle Felder in der Benutzeroberfläche standardmäßig statisch. Daher können wir auf sie zugreifen, indem wir den Schnittstellennamen direkt verwenden, genauso wie wir auf statische Felder der Klasse zugreifen, indem wir den Klassennamen und nicht das Objekt verwenden.

Das folgende Java-Beispielprogramm zeigt, wie wir auf die Schnittstellenfelder zugreifen können.

//interface declaration interface TestInterface{ public static int value = 100; //interface field public void display(); } //Interface implementation class TestClass implements TestInterface{ public static int value = 5000; //class fields public void display() { System.out.println('TestClass::display () method'); } public void show() { System.out.println('TestClass::show () method'); } } public class Main{ public static void main(String args()) { TestClass testObj = new TestClass(); //print interface and class field values. System.out.println('Value of the interface variable (value): '+TestInterface.value); System.out.println('Value of the class variable (value): '+testObj.value); } }

Ausgabe:

Beispiel für ein Schnittstellenfeld

Wie im obigen Programm gezeigt, kann auf die Schnittstellenfelder mit einem Schnittstellennamen gefolgt von einem Punktoperator (.) Und dem tatsächlichen Variablen- oder Feldnamen zugegriffen werden.

Die generische Schnittstelle in Java

Wir haben Java-Generika in unseren früheren Tutorials besprochen. Neben generischen Klassen, Methoden usw. können wir auch generische Schnittstellen haben. Generische Schnittstellen können auf ähnliche Weise angegeben werden, wie wir generische Klassen angeben.

Generische Schnittstellen werden mit Typparametern deklariert, die sie unabhängig von einem Datentyp machen.

Die allgemeine Syntax der generischen Schnittstelle lautet wie folgt:

beste kostenlose Computerreinigung und Reparatur
interface { //interface methods and variables }

Wenn wir nun die obige generische Schnittstelle in einer Klasse verwenden möchten, können wir haben die Klassendefinition wie unten gezeigt:

class implements interface_name { //class body }

Beachten Sie, dass wir mit der Klasse dieselbe Parameterliste angeben müssen wie mit der Schnittstelle.

Das folgende Java-Programm demonstriert die generischen Schnittstellen in Java.

//generic interface declaration interface MinInterface>{ T minValue(); } //implementation for generic interface class MinClassImpl> implements MinInterface { T() intArray; MinClassImpl(T() o) { intArray = o; } public T minValue() { T v = intArray(0); for (int i = 1; i intMinValue = new MinClassImpl (intArray); MinClassImpl charMinValue = new MinClassImpl(charArray); //call interface method minValue for int type array System.out.println('Min value in intOfArray: ' + intMinValue.minValue()); //call interface method minValue for char type array System.out.println('Min value in charOfArray: ' + charMinValue.minValue()); }

Ausgabe:

Beispielausgabe einer generischen Schnittstelle

Das obige Programm implementiert eine Schnittstelle, die eine Methode zum Ermitteln des Mindestwerts im Array enthält. Dies ist eine generische Schnittstelle. Die Klasse implementiert diese Schnittstelle und überschreibt die Methode. In der Hauptmethode rufen wir die Schnittstellenmethode auf, um den Mindestwert in einer Ganzzahl und einem Zeichenarray zu ermitteln.

Mehrere Schnittstellen in Java

In unserem Vererbungsthema haben wir gesehen, dass Java es einer Klasse nicht erlaubt, von mehreren Klassen zu erben, da dies zu einer Mehrdeutigkeit führt, die als „Diamantproblem“ bezeichnet wird.

Eine Klasse kann jedoch mehr als eine Schnittstelle erben oder implementieren. In diesem Fall spricht man von Mehrfachvererbung. Obwohl wir keine Mehrfachvererbung in Java über Klassen implementieren dürfen, können wir dies über Schnittstellen tun.

Das folgende Diagramm zeigt die Mehrfachvererbung mithilfe von Schnittstellen. Hier implementiert eine Klasse zwei Schnittstellen, d. H. Interface_one und Interface_two.

Mehrere Schnittstellen in Java

Beachten Sie, dass beim Implementieren einer Mehrfachschnittstelle durch eine Klasse die Schnittstellennamen in der Klassendeklaration durch Kommas getrennt sind. Wir können so viele Schnittstellen implementieren, wie wir mit der Komplexität umgehen können.

Das Java-Programm, das mehrere Schnittstellen demonstriert, ist unten dargestellt.

//Interface_One declaration interface Interface_One{ void print(); } //Interface_Two declaration interface Interface_Two{ void show(); } //multiple inheritance - DemoClass implementing Interface_One&Interface_Two class DemoClass implements Interface_One,Interface_Two{ public void print(){ //Override Interface_One print() System.out.println('Democlass::Interface_One_Print ()'); } public void show(){ //Override Interface_Two show() System.out.println('DemoClass::Interface_Two_Show ()'); } } public class Main{ public static void main(String args()){ DemoClass obj = new DemoClass(); //create DemoClass object and call methods obj.print(); obj.show(); } }

Ausgabe:

Beispiel für mehrere Schnittstellen

Kostenlose Alternativen zu Avast Cleanup Premium

Wie oben gezeigt, implementieren wir zwei Schnittstellen. Dann überschreiben wir ihre jeweiligen Methoden und rufen sie in der Hauptmethode auf.

Die Mehrfachvererbung in Java bietet alle Vorteile, die die Mehrfachvererbung in C ++ bietet. Im Gegensatz zur Mehrfachvererbung mithilfe von Klassen ist die Mehrfachvererbung mithilfe von Schnittstellen jedoch nicht eindeutig.

Schnittstellenvererbung In Java: Schnittstelle erweitert Schnittstelle

Wenn eine Klasse eine Schnittstelle implementiert, erfolgt dies mit dem Befehl „ Geräte ' Stichwort. In Java kann eine Schnittstelle eine andere Schnittstelle erben. Dies geschieht mit dem ‘ erweitert ' Stichwort. Wenn eine Schnittstelle eine andere Schnittstelle erweitert, heißt sie „ Schnittstellenvererbung ”In Java.

Schnittstelle erweitert Schnittstelle

Das Java-Programm zum Implementieren der Schnittstellenvererbung wird unten gezeigt.

//Interface_One declaration interface Interface_One{ void print(); } //Interface_Two declaration; inherits from Interface_One interface Interface_Two extends Interface_One{ void show(); } //multiple inheritance - DemoClass implementing Interface_Two class DemoClass implements Interface_Two{ public void print(){ //Override Interface_Two print() System.out.println('Democlass public class Main{ public static void main(String args()){ DemoClass obj = new DemoClass(); //create DemoClass object and call methods obj.print(); obj.show(); } }

Ausgabe:

Beispielausgabe einer Demo-Klasse

Wir haben dasselbe Programm, das wir für die Mehrfachvererbung verwendet haben, mithilfe von Schnittstellen geändert, um die Schnittstellenvererbung zu demonstrieren. Hier erweitern wir Interface_one in Interface_two und implementieren dann Interface_two in einer Klasse. Da Schnittstellen vererbt werden, stehen beide Methoden zum Überschreiben zur Verfügung.

Häufig gestellte Fragen

F # 1) Was ist die Verwendung der Schnittstelle in Java?

Antworten: Eine Schnittstelle in Java ist eine Entität, mit der eine 100% ige Abstraktion erreicht wird. Es kann nur abstrakte Methoden enthalten, die von der Klasse, die die Schnittstelle implementiert, überschrieben werden können.

Die Schnittstelle verhält sich in gewisser Weise wie eine Blaupause der Klasse, wobei sie der Klasse die Prototypen der abstrakten Methode und statischen Konstanten bereitstellt und die Klasse diese Methoden dann durch Implementieren der Schnittstelle überschreiben muss.

F # 2) Was sind die Vorteile der Schnittstelle in Java?

Antworten: Einige der Vorteile von Interface sind folgende:

  1. Die Schnittstelle fungiert als Blaupause der Klasse.
  2. Die Schnittstelle bietet 100% Abstraktion in Java, da sie alle abstrakten Methoden enthält.
  3. Schnittstellen können verwendet werden, um eine Mehrfachvererbung in Java zu erreichen. Java erlaubt nicht, von mehr als einer Klasse zu erben, aber eine Klasse kann mehrere Schnittstellen implementieren.

# 3) Kann eine Schnittstelle Methoden haben?

Antworten: Schnittstellen können Prototypen von Methoden sowie statische und endgültige Konstanten enthalten. Ab Java 8 können Schnittstellen jedoch statische und Standardmethoden enthalten.

F # 4) Können wir die Schnittstelle als endgültig deklarieren?

Antworten: Nein. Wenn wir eine Schnittstelle als endgültig deklarieren, kann die Klasse sie nicht implementieren. Ohne die Implementierung durch eine Klasse erfüllt die Schnittstelle keinen Zweck.

Weitere Informationen zu Schnittstellen

Schnittstellen sind Blaupausen wie Klassen, enthalten jedoch nur die Methodendeklaration. Es wird keine Implementierungsmethode geben. Alle Methoden in der Schnittstelle sind standardmäßig öffentlich abstrakt. Die Java 1.8-Schnittstelle kann statische und Standardmethoden haben.

Schnittstellen werden hauptsächlich in APIs verwendet.

Zum Beispiel: Stellen Sie sich vor, Sie entwerfen den Motor eines Fahrzeugs.

Wenn Sie mit dem Hardwareteil fertig sind, möchten Sie, dass einige der Softwarefunktionen von einem Client implementiert werden, der Ihre Engine verwendet. In diesem Fall können Sie also Ihre Motorfunktionen in einer Schnittstelle definieren.

Interface Engine { void changeGear(int a); void speedUp(int a); }

Regeln für die Schnittstelle

  • Die Klasse, die die Schnittstelle implementiert, sollte alle Methoden in der Schnittstelle implementieren.
  • Eine Schnittstelle kann endgültige Variablen enthalten.
public class Vehicle implements Engine { int speed; int gear; @Override public void speedUp(int a) { this.speed=a; System.out.println('speed'+speed); } @Override public void changeGear(int a) { this.gear=a; System.out.println('gear'+gear); } public static void main(String() args) { // TODO Auto-generated method stub Vehicle objv=new Vehicle(); objv.changeGear(3); objv.speedUp(70); } }

Regeln für die Schnittstelle zu befolgen

Hier ist die Fahrzeugklasse die Unterklasse, die die Motorschnittstelle implementiert.

Was sind abstrakte Klassen?

Eine abstrakte Klasse ist wie eine Klasse, hat jedoch abstrakte und konkrete Methoden. Abstrakte Methoden haben keine Implementierung. Es wird nur die Methodendeklaration haben.

Regeln für die Abstract-Klasse

  • Die abstrakte Klasse kann nicht instanziiert werden.
  • Eine untergeordnete Klasse, die die abstrakte Klasse erweitert, sollte alle abstrakten Methoden der übergeordneten Klasse implementieren, oder die untergeordnete Klasse sollte als abstrakte Klasse deklariert werden.

Wenn Sie eine Teilimplementierung entwerfen möchten, können Sie sich für eine abstrakte Klasse entscheiden.

Beispiel für ein abstraktes Klassenprogramm:

EmployeeDetails.java

public abstract class EmployeeDetails { private String name; private int emp_ID; public void commonEmpDetaills() { System.out.println('Name'+name); System.out.println('emp_ID'+emp_ID); } public abstract void confidentialDetails(int s,String p); }

Mitarbeiterdetails

Die Klasse, die die abstrakte Klasse erweitern wird.

HR.java

public class HR extends EmployeeDetails { private int salary; private String performance; @Override public void confidentialDetails(int s,String p) { this.salary=s; this.performance=p; System.out.println('salary=='+salary); System.out.println('performance=='+performance); } public static void main(String() args) { HR hr =new HR(); hr.confidentialDetails(5000,'good'); } }

hr-java

Wichtige zu beachtende Punkte:

  • In Interfaces haben nicht alle Methoden eine Methodenimplementierung.
  • Die Klasse, die die Schnittstelle implementiert, sollte alle Methoden in dieser bestimmten Schnittstelle implementieren.
  • Abstrakte Klassen können sowohl abstrakte als auch normale konkrete Methoden haben. Abstrakte Methoden haben keine Implementierung.
  • Die Klasse, die die abstrakte Klasse erweitert, sollte die Implementierung für alle abstrakten Methoden in der abstrakten Klasse haben.
  • Wenn die Unterklasse nicht über genügend Informationen verfügt, um die abstrakten Methoden zu implementieren, sollte die Unterklasse als abstrakte Klasse deklariert werden.

Fazit

In diesem Tutorial haben wir die grundlegenden Konzepte von Schnittstellen in Java vorgestellt. Wir haben die Definition der Schnittstelle sowie die Notwendigkeit von Schnittstellen erörtert. Wir haben ihre grundlegende Syntax und Definition untersucht. Anschließend haben wir erläutert, wie Schnittstellen verwendet werden, für die wir das Schlüsselwort 'implementiert' verwenden.

Wir haben gelernt, wie man mehrere Schnittstellen und die Schnittstellenvererbung in Java verwendet. Mit mehreren Schnittstellen können wir Mehrfachvererbung in Java implementieren. Die Schnittstellenvererbung erfolgt, wenn eine Schnittstelle eine andere Schnittstelle erweitert.

=> Besuchen Sie hier, um die Java-Schulungsreihe für alle zu sehen

Literatur-Empfehlungen

^