In Java sind Schnittstellen unerlässlich, wenn es darum geht, Klassenverträge festzulegen und die Codekonsistenz im Bereich der Java-Programmierung zu gewährleisten. Es dient als Blaupause für eine Klasse, indem es eine Reihe von Methoden beschreibt, die die implementierende Klasse implementieren muss. Die Abstraktion, Modularität und Wartbarkeit ihres Codes können Entwickler durch den Einsatz von Schnittstellen erreichen. Der verschiedene Schnittstellentypen in Java wird in diesem Abschnitt besprochen.
Marker-Schnittstellen
Markierungsschnittstellen, oft auch Tag-Schnittstellen genannt, sind Schnittstellen ohne deklarierte Methoden. Vereinfacht gesagt dienen sie als Marker und signalisieren, dass eine Klasse, die das Marker-Interface implementiert, bestimmte Eigenschaften oder Qualitäten hat. Die Java-Laufzeitumgebung und andere Tools nutzen diese APIs, um zusätzliche Funktionen oder Daten bereitzustellen. Serialisierbar, Klonbar und Remote sind einige Beispiele für Markierungsschnittstellen in Java.
Funktionale Schnittstellen
Im Rahmen der Verbesserungen an Lambda-Ausdrücken und der funktionalen Programmierung wurden Java 8 funktionale Schnittstellen hinzugefügt. Eine Schnittstelle, die genau eine abstrakte Methode besitzt, wird als funktional bezeichnet. Darüber hinaus sind Standard- und statische Methoden möglich. Viele funktionale Java-Programmierfunktionen, wie Lambda-Ausdrücke und Methodenreferenzen, nutzen funktionale Schnittstellen. Prädikat, Verbraucher, Funktion und Lieferant sind nur einige der integrierten Funktionsschnittstellen, die das Paket java.util.function bietet.
SAM-Schnittstellen (Single Abstract Method).
Vor Java 8 gab es bestimmte Arten von Funktionsschnittstellen, die SAM-Schnittstellen genannt wurden. Diese Schnittstellen können über eine beliebige Anzahl von Standard- oder statischen Methoden verfügen, jedoch nur über eine abstrakte Methode. Runnable, Comparator und MouseListener sind einige APIs aus der Zeit vor Java 8, die SAM-Schnittstellenbeispiele enthalten. Mit der Einführung funktionaler Schnittstellen in Java 8 können SAM-Schnittstellen mit Lambda-Ausdrücken verwendet und als funktionale Schnittstellen betrachtet werden.
Zeichenfolge in Datum umwandeln
Normale Schnittstellen
Die am weitesten verbreitete Art von Schnittstellen in Java sind normale Schnittstellen. Sie verfügen über eine oder mehrere abstrakte Methoden, die die Klassen, die die Schnittstelle implementieren, implementieren müssen. Ab Java 8 können normale Schnittstellen zusätzlich Standard- und statische Methoden enthalten. Normale Schnittstellen werden von Entwicklern verwendet, um die Regeln oder Anforderungen anzugeben, denen Klassen folgen müssen. List, Set und Map, die alle im Paket java.util enthalten sind, sind Beispiele für typische Java-Schnittstellen.
Mehrere Vererbungsschnittstellen
Java erlaubt Klassen die Implementierung mehrerer Schnittstellen, unterstützt jedoch nicht die Vererbung mehrerer Klassen. Schnittstellen, die von einer Klasse implementiert werden, um gleichzeitig zahlreiche Verträge zu definieren oder Verhalten zu erben, werden als Mehrfachvererbungsschnittstellen bezeichnet. Eine Klasse kann die von jeder Schnittstelle beschriebene Funktionalität bieten, indem sie mehrere Schnittstellen implementiert. Mithilfe dieser Funktionalität können Entwickler Code wiederverwenden und die Anpassungsfähigkeit ihrer Ideen erhöhen.
Hier sind Codebeispiele für jeden Schnittstellentyp in Java zusammen mit der entsprechenden Ausgabe:
Marker-Schnittstellen
MarkerInterfaceExample.java
Java-Zeichen in Ganzzahl umwandeln
import java.io.Serializable; // Marker Interface interface MyMarkerInterface extends Serializable { } public class MarkerInterfaceExample { public static void main(String[] args) { MyMarkerInterface obj = new MyMarkerInterface() { }; System.out.println(obj instanceof Serializable); // true } } Ausgabe:
true
Funktionale Schnittstellen
FunctionalInterfaceExample.java
import java.util.function.Predicate; public class FunctionalInterfaceExample { public static void main(String[] args) { Predicate isLengthGreaterThan5 = str -> str.length() > 5; System.out.println(isLengthGreaterThan5.test('Hello')); // false System.out.println(isLengthGreaterThan5.test('OpenAI')); // true } } Ausgabe:
false true
SAM-Schnittstellen (Single Abstract Method):
SAMInterfaceExample.java
interface MySAMInterface { void performAction(); } public class SAMInterfaceExample { public static void main(String[] args) { MySAMInterface obj = () -> System.out.println('Performing action'); obj.performAction(); // Performing action } } Ausgabe:
C-Programm für zweidimensionales Array
Performing action
Normale Schnittstellen
NormalInterfaceExample.java
import java.util.List; import java.util.ArrayList; interface MyInterface { void printMessage(); } class MyClass implements MyInterface { @Override public void printMessage() { System.out.println('Hello, World!'); } } public class NormalInterfaceExample { public static void main(String[] args) { MyInterface obj = new MyClass(); obj.printMessage(); // Hello, World! } } Ausgabe:
binärer Suchbaum]
Hello, World!
Mehrere Vererbungsschnittstellen:
MultipleInheritanceInterfaceExample.java
interface Interface1 { void method1(); } interface Interface2 { void method2(); } class MyClass implements Interface1, Interface2 { @Override public void method1() { System.out.println('Method 1'); } @Override public void method2() { System.out.println('Method 2'); } } public class MultipleInheritanceInterfaceExample { public static void main(String[] args) { MyClass obj = new MyClass(); obj.method1(); // Method 1 obj.method2(); // Method 2 } } Ausgabe:
Method 1 Method 2
Diese Beispiele veranschaulichen die Verwendung und das Verhalten verschiedener Schnittstellentypen in Java. Sie können jeden Codeausschnitt einzeln ausführen, um die entsprechende Ausgabe zu beobachten.
Zusammenfassend lässt sich sagen, dass Java-Schnittstellen eine wirksame Methode zum Spezifizieren von Verträgen und zum Erreichen von Codemodularität bieten. Schnittstellen sind für die Java-Entwicklung von wesentlicher Bedeutung, unabhängig davon, ob es sich um Markierungsschnittstellen handelt, die bestimmte Merkmale anzeigen, um funktionale Schnittstellen, die funktionale Programmierung ermöglichen, um reguläre Schnittstellen, die Verträge definieren, oder um Mehrfachvererbungsschnittstellen, die mehrere Verträge kombinieren. Java-Entwickler sind besser in der Lage, klaren, erweiterbaren Code zu erstellen, wenn sie die verschiedenen Schnittstellentypen und ihre Funktionen kennen.