bytte uttrykk

Repetisjon er læringens mor. Selv om vi allerede har snakket om Javas switch -nøkkelord tidligere, vil vi i dag gjennomgå det grunnleggende og grave i litt ny informasjon.

Java har to typer bryterkonstruksjoner : switch-setningen og switch-uttrykket. Switch-uttrykket ble offisielt i Java 14, etter å ha eksistert i to uoffisielle "forhåndsvisning"-varianter i versjon 12 og 13.

Men la oss starte fra begynnelsen. La oss huske hvordan en god gammel bryter så ut før versjon 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-setning er et sett med konstruksjoner som vil bli utført etter hverandre. Den lar deg ikke returnere en verdi. Hovedproblemet med å bruke en switch-setning er at du kan legge til et uendelig antall kasusuttrykk , og denne evnen blir ofte misbrukt av programmerere.

Java 12 så tillegget av en eksperimentell funksjon: en ny versjon av switch - ikke en switch-setning, men et switch-uttrykk - som kan gi en verdi, bruke funksjonell programmering internt og slå sammen kasussetninger som har en felles verdi, og dermed gjøre bygge kompakt.

I Java 12 kan du omskrive getProductTypeByName()- metoden som følger:

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

    };
}

Nå ser koden renere ut. Pilsyntaksen fra funksjonell programmering lar oss returnere verdier uten break -nøkkelordet, og generelt kan resultatet av å utføre svitsjen nå lagres til en variabel eller returneres via return - nøkkelordet.

Hvis vi ikke bare trenger å returnere et resultat, men også ha flere kodelinjer, vil bryteren vår se slik ut:

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 bryteruttrykket fortsatt en eksperimentell funksjon. For å gjøre det tilgjengelig, akkurat som i Java 12, må du bruke kommandoen --enable-preview når du kompilerer og kjører. Den viktigste, og egentlig eneste, "innovasjonen" av bryteren i Java 13 er yield -nøkkelordet, som erstattet 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;
}

Hovedforskjellen mellom yield og break er at break returnerer utførelseskontroll fra en sakserklæring , men yield returnerer resultatet av hele byttet , og fungerer som en intern returerklæring .

I Java 14 har instansen av operatøren endret seg og kan nå brukes slik:

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

I stedet for den litt stygge gamle måten hvor du ikke bare måtte sjekke variabelen ved å bruke instanceof , men også caste den til en bestemt type.

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

Disse endringene er en del av Amber-prosjektet, som tar sikte på å legge til støtte for mønstertilpasning til Java.

Takket være endringen i forekomsten av operatøren i versjon 14 og en utvidelse i versjon 16, kom mønstertilpasning tross alt inn i versjon 17. Riktignok eksisterer den bare som en forhåndsvisning foreløpig. Du kan prøve 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();
    };
}

Generelt sett bringer hver nye versjon flere og flere interessante funksjoner inn i språket, noe som gjør Java-utviklingen enda kulere.