Java 8 Interface Änderungen

Das Entwerfen von Schnittstellen war schon immer eine schwierige Aufgabe, denn wenn wir zusätzliche Methoden in die Interfaces einfügen möchten, erfordert dies Änderungen in allen implementierenden Klassen. Wenn ein Interface älter wird, kann die Anzahl der Klassen, die es implementieren, so groß werden, dass es nicht möglich ist, das Interface zu erweitern. Daher bieten die meisten Frameworks beim Entwerfen einer Anwendung eine Basisimplementierungsklasse an, die wir erweitern und deren Methoden wir überschreiben, die für unsere Anwendung anwendbar sind. Schauen wir uns die Standard-Interface-Methoden und statischen Interface-Methoden sowie die Gründe für ihre Einführung in den Java 8 Interface-Änderungen an.

Java Interface Standardmethode

Um eine Standardmethode im Java-Interface zu erstellen, müssen wir das Schlüsselwort „default“ zusammen mit der Methodensignatur verwenden. Zum Beispiel,

package com.journaldev.java8.defaultmethod;

public interface Interface1 {

	void method1(String str);
	
	default void log(String str){
		System.out.println("I1 logging::"+str);
	}
}

Beachten Sie, dass log(String str) die Standardmethode im Interface1 ist. Wenn eine Klasse Interface1 implementiert, ist es nicht zwingend erforderlich, eine Implementierung für die Standardmethoden des Interfaces bereitzustellen. Diese Funktion wird uns helfen, Schnittstellen mit zusätzlichen Methoden zu erweitern, wobei wir nur eine Standardimplementierung bereitstellen müssen. Angenommen, wir haben ein weiteres Interface mit folgenden Methoden:

package com.journaldev.java8.defaultmethod;

public interface Interface2 {

	void method2();
	
	default void log(String str){
		System.out.println("I2 logging::"+str);
	}

}

Wir wissen, dass Java uns nicht erlaubt, mehrere Klassen zu erweitern, weil dies zum „Diamond-Problem“ führen würde, bei dem der Compiler nicht entscheiden kann, welche Superklassenmethode verwendet werden soll. Mit den Standardmethoden würde dieses Problem auch bei Interfaces auftreten. Wenn eine Klasse sowohl Interface1 als auch Interface2 implementiert und die gemeinsame Standardmethode nicht implementiert, kann der Compiler nicht entscheiden, welche ausgewählt werden soll. Das Erweitern mehrerer Interfaces ist ein integraler Bestandteil von Java, man findet es sowohl in den Kern-Java-Klassen als auch in den meisten Unternehmensanwendungen und Frameworks. Um sicherzustellen, dass dieses Problem bei Interfaces nicht auftritt, ist es zwingend erforderlich, eine Implementierung für gemeinsame Standardmethoden von Interfaces bereitzustellen. Wenn also eine Klasse beide oben genannten Interfaces implementiert, muss sie eine Implementierung für die Methode log() bereitstellen, sonst wird der Compiler einen Kompilierungsfehler ausgeben. Eine einfache Klasse, die sowohl Interface1 als auch Interface2 implementiert, wäre:

package com.journaldev.java8.defaultmethod;

public class MyClass implements Interface1, Interface2 {

	@Override
	public void method2() {
	}

	@Override
	public void method1(String str) {
	}

	@Override
	public void log(String str){
		System.out.println("MyClass logging::"+str);
		Interface1.print("abc");
	}
}

Wichtige Punkte über Java Interface Standardmethoden:

• Java Interface Standardmethoden helfen uns, Interfaces zu erweitern, ohne die Implementierungsklassen zu beeinträchtigen.
• Java Interface Standardmethoden haben die Unterschiede zwischen Interfaces und abstrakten Klassen verringert.
• Java 8 Interface Standardmethoden helfen uns, Utility-Klassen zu vermeiden, da alle Methoden der Collections-Klasse in den Interfaces selbst bereitgestellt werden können.
• Java Interface Standardmethoden helfen uns, Basismplementierungsklassen zu entfernen, wir können eine Standardimplementierung bereitstellen und die Implementierungsklassen können wählen, welche sie überschreiben möchten.
• Einer der Hauptgründe für die Einführung von Standardmethoden in Interfaces ist die Verbesserung der Collections API in Java 8 zur Unterstützung von Lambda-Ausdrücken.
• Wenn eine Klasse in der Hierarchie eine Methode mit derselben Signatur hat, werden die Standardmethoden irrelevant. Eine Standardmethode kann keine Methode aus java.lang.Object überschreiben. Der Grund dafür ist sehr einfach: Object ist die Basisklasse für alle Java-Klassen. Selbst wenn wir Object-Klassenmethoden als Standardmethoden in Interfaces definieren würden, wäre dies nutzlos, da immer die Object-Klassenmethode verwendet wird. Daher können wir keine Standardmethoden haben, die Object-Klassenmethoden überschreiben, um Verwirrung zu vermeiden.
• Java Interface Standardmethoden werden auch als Defender Methods oder Virtual Extension Methods bezeichnet.

Java Interface Statische Methode

Die statische Methode des Java-Interfaces ähnelt der Standardmethode, mit dem Unterschied, dass wir sie in den Implementierungsklassen nicht überschreiben können. Diese Funktion hilft uns, unerwünschte Ergebnisse bei schlechter Implementierung in den Implementierungsklassen zu vermeiden. Schauen wir uns dies anhand eines einfachen Beispiels an.

package com.journaldev.java8.staticmethod;

public interface MyData {

	default void print(String str) {
		if (!isNull(str))
			System.out.println("MyData Print::" + str);
	}

	static boolean isNull(String str) {
		System.out.println("Interface Null Check");

		return str == null ? true : "".equals(str) ? true : false;
	}
}

Nun sehen wir uns eine Implementierungsklasse an, die die Methode isNull() mit einer schlechten Implementierung hat.

package com.journaldev.java8.staticmethod;

public class MyDataImpl implements MyData {

	public boolean isNull(String str) {
		System.out.println("Impl Null Check");

		return str == null ? true : false;
	}
	
	public static void main(String args[]){
		MyDataImpl obj = new MyDataImpl();
		obj.print("");
		obj.isNull("abc");
	}
}

Beachten Sie, dass isNull(String str) eine einfache Klassenmethode ist, sie überschreibt nicht die Interface-Methode. Wenn wir beispielsweise die Annotation @Override zur isNull()-Methode hinzufügen würden, würde dies zu einem Compilerfehler führen. Wenn wir jetzt die Anwendung ausführen, erhalten wir folgende Ausgabe.

Interface Null Check
Impl Null Check

Wenn wir die Interface-Methode von statisch auf Standard ändern, erhalten wir folgende Ausgabe.

Impl Null Check
MyData Print::
Impl Null Check

Die statische Interface-Methode ist nur für Interface-Methoden sichtbar, wenn wir die isNull()-Methode aus der Klasse MyDataImpl entfernen, können wir sie nicht für das Objekt MyDataImpl verwenden. Wie bei anderen statischen Methoden können wir statische Interface-Methoden jedoch mit dem Klassennamen verwenden. Zum Beispiel wäre eine gültige Aussage:

boolean result = MyData.isNull("abc");

Wichtige Punkte über statische Java Interface Methoden:

• Die statische Methode des Java-Interfaces ist Teil des Interfaces, wir können sie nicht für Objekte der Implementierungsklasse verwenden.
• Statische Java Interface Methoden eignen sich gut für Utility-Methoden, zum Beispiel für Nullprüfungen, Sortieren von Sammlungen usw.
• Statische Java Interface Methoden helfen uns, Sicherheit zu bieten, indem sie verhindern, dass Implementierungsklassen sie überschreiben.
• Wir können keine statischen Interface-Methoden für Object-Klassenmethoden definieren, wir erhalten den Compilerfehler „Diese statische Methode kann die Instanzmethode von Object nicht verbergen“. Dies ist nicht erlaubt in Java, da Object die Basisklasse für alle Klassen ist und wir nicht eine Klassenstufe statische Methode und eine andere Instanzmethode mit derselben Signatur haben können.
• Wir können statische Java Interface Methoden verwenden, um Utility-Klassen wie Collections zu entfernen und alle deren statischen Methoden in das entsprechende Interface zu verschieben, was das Finden und Verwenden erleichtert.

Java Funktionale Interfaces

Bevor ich den Beitrag abschließe, möchte ich eine kurze Einführung zu funktionalen Interfaces geben. Ein Interface mit genau einer abstrakten Methode wird als Funktionales Interface bezeichnet. Eine neue Annotation @FunctionalInterface wurde eingeführt, um ein Interface als Funktionales Interface zu kennzeichnen. Die Annotation @FunctionalInterface ist eine Einrichtung, um die versehentliche Hinzufügung von abstrakten Methoden in den funktionalen Interfaces zu vermeiden. Es ist optional, aber es ist eine gute Praxis, sie zu verwenden. Funktionale Interfaces sind ein lang erwartetes und sehr gesuchtes Feature von Java 8, da sie es uns ermöglichen, sie mit Lambda-Ausdrücken zu instanziieren. Ein neues Paket java.util.function mit einer Reihe von funktionalen Interfaces wurde hinzugefügt, um Zieltypen für Lambda-Ausdrücke und Methodenreferenzen bereitzustellen. Wir werden in zukünftigen Beiträgen auf funktionale Interfaces und Lambda-Ausdrücke eingehen.