Java 9 Diamond Operator für anonyme innere Klassen – Typinferenz endlich erlaubt

Das Problem vor Java 9

Der Diamond Operator (<>) wurde in Java 7 eingeführt, um redundante Typangaben bei Generics zu vermeiden:

List<String> list = new ArrayList<>(); // OK in Java 7

Aber: Bei anonymen inneren Klassen war er verboten – der Compiler konnte den Typ nicht inferieren.

Java 9 Lösung

Ab Java 9 funktioniert <> auch bei anonymen Klassen, wenn der Typ aus dem Kontext inferierbar ist (Ziel-Typisierung).

Vergleich

Vor Java 9 (explizit)

Handler<Integer> h1 = new Handler<Integer>(1) { ... };
Handler<? extends Number> h2 = new Handler<Number>(2) { ... };
Handler<?> h3 = new Handler<Object>("test") { ... };

Ab Java 9 (mit Diamond)

Handler<Integer> h1 = new Handler<>(1) { ... };
Handler<? extends Number> h2 = new Handler<>(2) { ... };
Handler<?> h3 = new Handler<>("test") { ... };

Vollständiges Beispiel

public class DiamondDemo {
    public static void main(String[] args) {
        Handler<Integer> intHandler = new Handler<>(1) {
            @Override public void handle() { System.out.println(content); }
        };
        intHandler.handle();

        Handler<? extends Number> numHandler = new Handler<>(2) {
            @Override public void handle() { System.out.println(content); }
        };
        numHandler.handle();

        Handler<?> anyHandler = new Handler<>("Test") {
            @Override public void handle() { System.out.println(content); }
        };
        anyHandler.handle();
    }
}

abstract class Handler<T> {
    public T content;
    public Handler(T content) { this.content = content; }
    abstract void handle();
}

Ausgabe:

1
2
Test

Voraussetzungen für Typinferenz

• Ziel-Typ (Variable, Parameter, Return) muss konkret parametrisiert sein (Handler<Integer>, nicht Handler<T>).
• Konstruktor-Argumente müssen zum inferierten Typ passen.
• Funktioniert auch mit new EnumMap<>(MyEnum.class) etc.

Einschränkungen

• Keine Inferenz bei rohen Typen (Handler h = new Handler<>() → Warnung/Fehler).
• Nicht anwendbar auf Lambda-Ausdrücke (dort gar keine new-Syntax).
• Bei Wildcards (? extends Number) inferiert der Compiler den obere Schranke (Number).

Fazit

Ein konsequenter Schritt zur Vervollständigung der Typinferenz. Macht anonyme Klassen mit Generics lesbarer und konsistenter mit dem Rest der Sprache.