skifte udtryk

Gentagelse er læringens moder. Selvom vi allerede har talt om Javas switch -nøgleord tidligere, vil vi i dag gennemgå det grundlæggende og grave i nogle nye oplysninger.

Java har to typer switch- konstruktioner: switch-sætningen og switch-udtrykket. Switch-udtrykket blev officielt i Java 14, efter at have eksisteret i to uofficielle "preview"-varianter i version 12 og 13.

Men lad os starte fra begyndelsen. Lad os huske, hvordan en god gammel switch så ud før 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-sætning er et sæt konstruktioner, der vil blive udført efter hinanden. Det lader dig ikke returnere en værdi. Hovedproblemet ved at bruge en switch-sætning er, at du kan tilføje et uendeligt antal kasusudtryk , og denne evne bliver ofte misbrugt af programmører.

Java 12 så tilføjelsen af ​​en eksperimentel funktion: en ny version af switch - ikke en switch-sætning, men et switch-udtryk - som kan give en værdi, bruge funktionel programmering internt og flette case-sætninger, der har en fælles værdi, og derved gøre konstruere kompakt.

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

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

    };
}

Nu ser koden renere ud. Pilesyntaksen fra funktionel programmering lader os returnere værdier uden break nøgleordet, og generelt kan resultatet af udførelse af switchen nu gemmes til en variabel eller returneres via return nøgleordet.

Hvis vi ikke kun skal returnere et resultat, men også have flere linjer kode, så vil vores switch se sådan ud:

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-udtrykket stadig en eksperimentel funktion. For at gøre det tilgængeligt, ligesom i Java 12, skal du bruge kommandoen --enable-preview, når du kompilerer og kører. Den vigtigste og i det væsentlige eneste "innovation" af switchen i Java 13 er yield nøgleordet, som erstattede 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ørste forskel mellem yield og break er, at break returnerer udførelseskontrol fra en case -erklæring, men yield returnerer resultatet af hele skiftet , der fungerer som en intern return -erklæring.

I Java 14 er instansen af ​​operatoren ændret og kan nu bruges sådan her:

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

I stedet for den lidt grimme gamle måde, hvor du ikke kun skulle tjekke variablen ved hjælp af instanceof , men også caste den til en bestemt type.

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

Disse ændringer er en del af Amber-projektet, som har til formål at tilføje understøttelse af mønstertilpasning til Java.

Takket være ændringen i instansen af ​​operatøren i version 14 og en udvidelse i version 16, kom mønstertilpasning trods alt ind i version 17. Sandt nok eksisterer den kun som en forhåndsvisning indtil videre. 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 bringer hver ny version flere og flere interessante funktioner ind i sproget, hvilket gør Java-udvikling endnu sejere.