Java Diamond Operator:Vereinfachen Sie Generics in Java 7+

Java Diamond-Operator

Der Diamantoperator wurde in Java 7 eingeführt, um den Code für Generics besser lesbar zu machen. Ein Generikum ist eine Art Argument. Mit generic können wir jede Art von Objekt übergeben, das von den Klassenmethoden verarbeitet werden soll. Wenn wir beispielsweise vor Java 7 eine Liste mit Zeichenfolgen erstellen, müssen wir die folgende Syntax verwenden, um eine Liste mit Zeichenfolgen mit einem ArrayList-Objekt zu instanziieren.

List<String> listOfStrings = new ArrayList<String>();

Ab Java 7 können wir den Diamantoperator verwenden, um die obige Syntax wie folgt zu vereinfachen:-

List<String> listOfStrings = new ArrayList<>();

Es konnte jedoch nicht mit anonymen inneren Klassen verwendet werden. Beispielsweise können wir den Objekttyp des Diamantoperators in der folgenden Syntax vor Java 9 nicht weglassen.

Handler<Integer> intHandler = new Handler<Integer>(1) {
 @Override
 public void handle() {
 System.out.println(content);
 }
};

Diamant-Operator in der anonymen Klasse

In Java 9 kann der Diamantoperator auch mit einer anonymen Klasse verwendet werden, um den Code zu vereinfachen und die Lesbarkeit zu verbessern.

Handler<Integer> intHandler = new Handler<>(1) {
 @Override
 public void handle() {
 System.out.println(content);
 }
};

Diamantoperator in Java 7, Java 8

Im folgenden Beispiel haben wir anonyme Klassen für einen abstrakten Klassenhandler erstellt, der ein generisches Argument akzeptiert und den Objekttyp beim Erstellen der anonymen Klasse übergibt, da wir das Typargument übergeben müssen, sonst wird das Programm nicht kompiliert.

Beispiel

public class Tester {
 public static void main(String[] args) {
 // create an Anonymous class to handle 1
 // Here we need to pass Type arguments in diamond operator 
 // before Java 9 otherwise compiler will complain error
 Handler<Integer> intHandler = new Handler<Integer>(1) {
 @Override
 public void handle() {
 System.out.println(content);
 }
 };
 intHandler.handle();
 // create an Anonymous class to handle 2 
 Handler<? extends Number> intHandler1 = new Handler<Number>(2) {
 @Override
 public void handle() {
 System.out.println(content);
 }
 };
 intHandler1.handle();
 Handler<?> handler = new Handler<Object>("test") {
 @Override
 public void handle() {
 System.out.println(content);
 }
 };
 handler.handle(); 
 } 
}
abstract class Handler<T> {
 public T content;
 public Handler(T content) {
 this.content = content; 
 }
 
 abstract void handle();
}

Ausgabe

Lassen Sie uns das obige Programm kompilieren und ausführen. Dies führt zu folgendem Ergebnis:-

1
2
Test

Diamond Operator ab Java 9

Mit Java 9 können wir den Operator <> mit anonymer Klasse verwenden, wie unten gezeigt.

Beispiel

Im folgenden Beispiel haben wir anonyme Klassen für einen abstrakten Klassenhandler erstellt, der beim Erstellen der anonymen Klasse ein generisches Argument akzeptiert, jedoch ohne den Objekttyp, da wir das Typargument nicht übergeben müssen. Der Compiler leitet den Typ selbst ab.

public class Tester {
 public static void main(String[] args) {
 // create an Anonymous class to handle 1
 // Here we do not need to pass Type arguments in diamond operator 
 // as Java 9 compiler can infer the type automatically
 Handler<Integer> intHandler = new Handler<>(1) {
 @Override
 public void handle() {
 System.out.println(content);
 }
 };
 intHandler.handle();
 Handler<? extends Number> intHandler1 = new Handler<>(2) {
 @Override
 public void handle() {
 System.out.println(content);
 }
 };
 intHandler1.handle();
 Handler<?> handler = new Handler<>("test") {
 @Override
 public void handle() {
 System.out.println(content);
 }
 };
 handler.handle(); 
 } 
}
abstract class Handler<T> {
 public T content;
 public Handler(T content) {
 this.content = content; 
 }
 
 abstract void handle();
}

Ausgabe

Lassen Sie uns das obige Programm kompilieren und ausführen. Dies führt zu folgendem Ergebnis:-

1
2
Test