växla uttryck

Upprepning är lärandets moder. Även om vi redan pratat om Javas switch- sökord tidigare, kommer vi idag att se över grunderna och gräva i lite ny information.

Java har två typer av switch- konstruktioner: switch-satsen och switch-uttrycket. Switch-uttrycket blev officiellt i Java 14, efter att ha funnits i två inofficiella "förhandsgransknings"-varianter i version 12 och 13.

Men låt oss börja från början. Låt oss komma ihåg hur en gammal bra switch såg ut före version 12:

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;
}

En switch-sats är en uppsättning konstruktioner som kommer att exekveras en efter en. Det låter dig inte returnera ett värde. Det största problemet med att använda en switch-sats är att du kan lägga till ett oändligt antal kasusuttryck , och denna förmåga missbrukas ofta av programmerare.

Java 12 såg tillägget av en experimentell funktion: en ny version av switch – inte en switch-sats, utan ett switch-uttryck – som kan ge ett värde, använda funktionell programmering internt och slå samman fallsatser som har ett gemensamt värde, vilket gör att bygga kompakt.

I Java 12 kan du skriva om metoden getProductTypeByName() enligt följande:

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

    };
}

Nu ser koden renare ut. Pilsyntaxen från funktionell programmering låter oss returnera värden utan nyckelordet break , och generellt sett kan resultatet av att utföra switchen nu sparas till en variabel eller returneras via nyckelordet return .

Om vi ​​inte bara behöver returnera ett resultat utan också ha flera rader kod, så skulle vår switch se ut så här:

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;
}

I Java 13 var switch-uttrycket fortfarande en experimentell funktion. För att göra det tillgängligt, precis som i Java 12, måste du använda kommandot --enable-preview när du kompilerar och kör. Den huvudsakliga, och i princip enda, "innovationen" av switchen i Java 13 är nyckelordet yield , som ersatte break .

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;
}

Den största skillnaden mellan yield och break är att break returnerar exekveringskontroll från en case -sats, men yield returnerar resultatet av hela växlingen och fungerar som en intern retursats .

I Java 14 har instansen av operatorn ändrats och kan nu användas så här:

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

Istället för det lite fula gamla sättet där du inte bara var tvungen att kontrollera variabeln med hjälp av instanceof , utan även casta den till en specifik typ.

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

Dessa ändringar är en del av Amber-projektet, som syftar till att lägga till stöd för mönstermatchning till Java.

Tack vare ändringen i instansen av operatorn i version 14 och en tillägg i version 16, kom mönstermatchning trots allt till version 17. Det är sant, det finns bara som en förhandsvisning för närvarande. Du kan prova det med --enable-preview :

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

Generellt sett tillför varje ny version fler och fler intressanta funktioner i språket, vilket gör Java-utvecklingen ännu coolare.