Ausdruck wechseln

Wiederholung ist die Mutter des Lernens. Obwohl wir bereits früher über das Java- Schlüsselwort „ switch“ gesprochen haben , werden wir heute die Grundlagen besprechen und uns mit einigen neuen Informationen befassen.

Java verfügt über zwei Arten von Switch- Konstrukten: die Switch-Anweisung und den Switch-Ausdruck. Der Switch-Ausdruck wurde in Java 14 offiziell, nachdem er in den Versionen 12 und 13 in zwei inoffiziellen „Vorschau“-Varianten existierte.

Aber fangen wir von vorne an. Erinnern wir uns, wie ein guter alter Switch vor Version 12 aussah:

public String getProductTypeByName(String product) {
    String productType = "";

    switch (product) {
        case "Apple":
            productType = "Fruit";
            break;

        case "Peach":
            productType = "Fruit";
            break;

        case "Raspberry":
            productType = "Berry";
            break;

        case "Cherry":
            productType = "Berry";
            break;

        case "Tomato":
            productType = "Vegetable";
            break;

        default:
            productType = "other";
            break;
    }
        
    return productType;
}

Eine Switch-Anweisung ist eine Reihe von Konstrukten, die nacheinander ausgeführt werden. Sie können keinen Wert zurückgeben. Das Hauptproblem bei der Verwendung einer Switch-Anweisung besteht darin, dass Sie unendlich viele Case- Ausdrücke hinzufügen können, und diese Fähigkeit wird von Programmierern häufig missbraucht.

In Java 12 wurde eine experimentelle Funktion hinzugefügt: eine neue Version von Switch – keine Switch-Anweisung, sondern ein Switch-Ausdruck – die einen Wert liefern, intern funktionale Programmierung verwenden und Case-Anweisungen mit einem gemeinsamen Wert zusammenführen kann, wodurch die kompakt konstruieren.

In Java 12 können Sie die Methode getProductTypeByName() wie folgt umschreiben:

public String getProductTypeByName(String product) {
    return switch (product) {
        case "Apple", "Peach" -> "Fruit";
        case "Raspberry", "Cherry" -> "Berry";
        case "Tomato" -> "Vegetable";
        default -> "other";

    };
}

Jetzt sieht der Code sauberer aus. Mit der Pfeilsyntax aus der funktionalen Programmierung können wir Werte ohne das Schlüsselwort „ break“ zurückgeben , und im Allgemeinen kann das Ergebnis der Ausführung des Schalters jetzt in einer Variablen gespeichert oder über das Schlüsselwort „ return“ zurückgegeben werden.

Wenn wir nicht nur ein Ergebnis zurückgeben müssen, sondern auch mehrere Codezeilen haben müssen, dann würde unser Schalter so aussehen:

public String getProductTypeByName(String product) {
    var result = switch (product) {
        case "Apple", "Peach" -> {
            System.out.println("This is a Fruit");
            break "Fruit";
        }
        case "Raspberry", "Cherry" -> {
            System.out.println("This is a Berry");
            break "Berry";
        }
        case "Tomato" -> {
            System.out.println("This is a Vegetable");
            break "Vegetable";
        }
        default -> {
            break "other";
        }

    };
     return result;
}

In Java 13 war der Switch-Ausdruck noch eine experimentelle Funktion. Um es verfügbar zu machen, müssen Sie, genau wie in Java 12, beim Kompilieren und Ausführen den Befehl --enable-preview verwenden . Die wichtigste und im Wesentlichen einzige „Innovation“ des Schalters in Java 13 ist das Schlüsselwort yield , das break ersetzte .

public String getProductTypeByName(String product) {
    var result = switch (product) {
        case "Apple", "Peach" -> {
            System.out.println("This is a Fruit");
            yield "Fruit";
        }
        case "Raspberry", "Cherry" -> {
            System.out.println("This is a Berry");
            yield "Berry";
        }
        case "Tomato" -> {
            System.out.println("This is a Vegetable");
            yield "Vegetables";
        }
        default -> {
            System.out.println("Other");
            yield "other";
        }

    };
    return result;
}

Der Hauptunterschied zwischen yield und break besteht darin, dass break die Ausführungskontrolle einer case- Anweisung zurückgibt, yield jedoch das Ergebnis des gesamten switch zurückgibt und sich wie eine interne return- Anweisung verhält.

In Java 14 hat sich der Instanzof- Operator geändert und kann nun wie folgt verwendet werden:

if (o instanceof String s) {
s.toLowerCase();
}

Anstelle der etwas hässlichen alten Methode, bei der man die Variable nicht nur mit „ instanceof“ überprüfen , sondern sie auch in einen bestimmten Typ umwandeln musste.

if(s instanceof String) {
((String) s).toLowerCase();
}

Diese Änderungen sind Teil des Amber-Projekts, dessen Ziel es ist, Java um Unterstützung für den Mustervergleich zu erweitern.

Dank der Änderung des Instanzoperators in Version 14 und einer Erweiterung in Version 16 hat es der Mustervergleich nun doch in Version 17 geschafft. Es stimmt, es existiert vorerst nur als Vorschau. Sie können es mit --enable-preview ausprobieren :

public String getObjectType(Object object) {
    return switch (object) {
        case Integer i -> "Integer";
        case Long l -> "Long";
        case String s -> "String";
        default -> object.toString();
    };
}

Generell bringt jede neue Version immer mehr interessante Features in die Sprache, was die Java-Entwicklung noch cooler macht.