van uitdrukking wisselen

Herhaling is de moeder van leren. Hoewel we het eerder al hadden over Java's switch -trefwoord, zullen we vandaag de basis doornemen en wat nieuwe informatie induiken.

Java heeft twee soorten switch- constructies: de switch-instructie en de switch-expressie. De switch-expressie werd officieel in Java 14 en bestond in twee niet-officiële "preview"-varianten in versie 12 en 13.

Maar laten we bij het begin beginnen. Laten we ons herinneren hoe een goede oude schakelaar eruit zag vóór versie 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;
}

Een switch-statement is een set constructies die na elkaar worden uitgevoerd. U kunt geen waarde retourneren. Het grootste probleem met het gebruik van een switch-instructie is dat je een oneindig aantal case- expressies kunt toevoegen, en deze mogelijkheid wordt vaak misbruikt door programmeurs.

Java 12 zag de toevoeging van een experimentele functie: een nieuwe versie van switch - geen switch-instructie, maar een switch-expressie - die een waarde kan opleveren, intern functionele programmering kan gebruiken en case-instructies met een gemeenschappelijke waarde kan samenvoegen, waardoor de compact bouwen.

In Java 12 kunt u de methode getProductTypeByName() als volgt herschrijven:

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

    };
}

Nu ziet de code er schoner uit. Met de pijlsyntaxis van functioneel programmeren kunnen we waarden retourneren zonder het sleutelwoord break , en in het algemeen kan het resultaat van het uitvoeren van de omschakeling nu worden opgeslagen in een variabele of worden geretourneerd via het sleutelwoord return .

Als we niet alleen een resultaat moeten retourneren, maar ook meerdere regels code moeten hebben, dan ziet onze schakelaar er als volgt uit:

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 was de switch-expressie nog een experimentele functie. Om het beschikbaar te maken, net als in Java 12, moet u de opdracht --enable-preview gebruiken tijdens het compileren en uitvoeren. De belangrijkste en eigenlijk enige "innovatie" van de switch in Java 13 is het yield- sleutelwoord, dat break verving .

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

Het belangrijkste verschil tussen yield en break is dat break uitvoeringsbesturing retourneert vanuit een case- instructie, maar yield retourneert het resultaat van de gehele omschakeling en gedraagt ​​zich als een interne return- instructie.

In Java 14 is de instanceof- operator gewijzigd en kan deze nu als volgt worden gebruikt:

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

In plaats van de ietwat lelijke oude manier waarbij je niet alleen de variabele moest controleren met behulp van instanceof , maar deze ook naar een specifiek type moest casten.

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

Deze wijzigingen maken deel uit van het Amber-project, dat tot doel heeft ondersteuning voor patroonvergelijking toe te voegen aan Java.

Dankzij de verandering in de instanceof operator in versie 14 en een uitbreiding in versie 16, is pattern matching toch in versie 17 gehaald. Toegegeven, het bestaat voorlopig alleen als voorbeeld. Je kunt het uitproberen met --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();
    };
}

Over het algemeen brengt elke nieuwe versie steeds meer interessante functies in de taal, wat Java-ontwikkeling nog cooler maakt.