Switch-expressie versus switch-instructie

Bij het schrijven van code met veel voorwaarden, heb je vast een if-else of een switch statement gebruikt. Maar dit alternatief voor de if-else heeft nadelen. Sommige mensen hebben de switch- instructie zelfs een "anti-patroon" genoemd .

Maar er is goed nieuws: nieuwe versies van Java hebben veel veranderingen in de syntaxis van de taal gebracht, en een van die veranderingen is van invloed op switch . Gefascineerd? Laten we er dan in duiken.

Om te beginnen is het de moeite waard om te verduidelijken waarom switch een anti-patroon is. Beschouw de volgende code:

switch (condition) {
    case "DECEMBER":
        seasonNumber = 1;
        break;
    case "JANUARY":
        seasonNumber = 1;
        break;
    case "FEBRUARY":
        seasonNumber = 1;
        break;
    default:
        seasonNumber = 0;
}

Oké, het is dus nog niet helemaal duidelijk waarom dit een "anti-patroon" is.

Maar wat als we meer casusblokken toevoegen en de code er nu als volgt uitziet:

switch (condition) {
    case "DECEMBER":
        seasonNumber = 1;
        break;
    case "JANUARY":
        seasonNumber = 1;
        break;
    case "FEBRUARY":
        seasonNumber = 1;
        break;
    case “MARCH”:
        seasonNumber = 2;
        break;
    case “APRIL”:
        seasonNumber = 2;
        break;
    case “MAY”:
        seasonNumber = 2;
        break;
    default:
        seasonNumber = 0;
}

Laten we nog een paar regels toevoegen - de code wordt langer. Later kunnen we steeds meer regels toevoegen, en niemand zal ons hiervan weerhouden.

Dit is de kern van het probleem: nadat we in eerste instantie een compacte switch- instructie hebben gemaakt, voegen we er steeds meer code aan toe, die steeds meer ruimte in beslag nemen - meer dan op het scherm past - en de code onhandig maken om te lezen en te onderhouden.

Verschil tussen de switch-instructie en de switch-expressie

Java 14 introduceerde een nieuwe en verbeterde switch. Het is geen switch - statement , maar eerder een switch - expressie .

Wat is het verschil, vraag je? Het verschil is dat een instructie een instructie is die een bepaalde reeks bewerkingen uitvoert, maar een uitdrukking is een stuk code dat een berekening uitvoert en een resultaat retourneert.

Met andere woorden, nu kunt u het resultaat van een omschakeling naar een variabele opslaan.

Genoeg gepraat. Laten we nu eens kijken hoe de nieuwe schakelaar eruit ziet:

var result = switch(month) {
     case DECEMBER, JANUARY, FEBRUARY -> 1;
     case MARCH, APRIL, MAY -> 2;
    case JUNE, JULY, AUGUST -> 3;
    case SEPTEMBER, OCTOBER, NOVEMBER -> 4;
    default -> 0; 
};

Het eerste dat opvalt, is hoe compact de code is. Code die vroeger het grootste deel van het scherm in beslag nam, beslaat nu een paar regels en ziet er veel leesbaarder uit.

-> exploitant

Let ook op de operator -> (pijloperator). Wellicht ben je er al bekend mee als je ervaring hebt met lambda-uitdrukkingen.

Dat betekent dat je nu een cool ogende schakelaar kunt schrijven in de stijl van een lambda-statement. De pijloperator geeft aan dat de compiler niet doorgaat naar de volgende case- expressie (als het huidige case- blok geen break- of return -instructie heeft ), maar u in plaats daarvan de waarde van de expressie rechts van de pijl geeft.

Je kunt ook code schrijven die geen uitdrukking is en die simpelweg bepaalde acties uitvoert in plaats van iets terug te geven:

switch(condition) {
    case TRUE, FALSE -> System.out.println("True/false");
  
    default -> System.out.println("Another");
}

Merk op dat switch niet langer een break statement heeft. Het is verwijderd in Java 13 en vervangen door opbrengst .

Wat is rendement en waar kan het worden gebruikt?

Als een schakelaar uit een enkele regel bestaat, retourneert de operator -> zelf de waarde. Maar wat als we niet één, maar veel regels code hebben? In dergelijke gevallen retourneert de pijloperator geen waarde, aangezien er meerdere regels zijn, niet één.

Misschien kunnen we retour gebruiken ? Het wordt tenslotte gebruikt om waarden in Java te retourneren. Helaas, nee, retourneren gaat niet met een overstap. Dus wat kunnen we gebruiken? Vroeger was er break , maar dat is verwijderd in Java 13. Maar in plaats daarvan hebben we nu yield — een nieuw sleutelwoord dat u helpt een waarde van een switch terug te geven. Het is analoog aan het retourneren van instructies in methoden.

var result = switch(condition) {
//…
case "Hi" -> "greeting"
//…
};  

Deze code bevat een enkele regel en de operator -> retourneert "begroeting".

Maar als we een codeblok hebben:

var result = switch(condition) {
//…
case "Hi" -> {
// Your code
 Here you need to return "greeting"
	}
};  

Het sleutelwoord dat u zal helpen een waarde terug te geven, is opbrengst :

var result = switch(condition) {
//…
case "Hi" -> {
// Your code
 yield "greeting";

	}
};

yield is toegevoegd in Java 13 voor gevallen waarin we meer dan één regel code in een case-blok hebben en we een resultaat moeten retourneren.

U staat waarschijnlijk te popelen om de nieuwe switch in uw code uit te proberen , maar vergeet niet dat u hiervoor Java 14 of hoger nodig heeft. Bij eerdere versies is deze schakeloptie alleen beschikbaar als u de vlag "--enable-preview" opgeeft op de opdrachtregel, aangezien deze vóór versie 14 deel uitmaakte van de technische preview en geen volwaardig onderdeel van de taal.

Dat is het voor nu! Tot snel!