Java Switch Statement

Lite teori om Java Switch

Föreställ dig att du är en riddare som stannar vid en vägskäl. Om du går till vänster kommer du att förlora din häst. Om du går rätt kommer du att få kunskap. Hur skulle vi representera denna situation i kod? Du vet förmodligen redan att vi använder konstruktioner som om-då och om-då-annan för att fatta dessa beslut.

if (turn_left) { 
    System.out.println("You will lose your horse"); 
}
if (turn_right) {
    System.out.println("You will gain knowledge");
}
else 
    System.out.println("So you're just going to stand there?");

Men vad händer om vägen inte delar sig i två, utan i tio? Du har vägar som är "helt till höger", "lite till vänster om det", "lite mer till vänster" och så vidare, totalt 10 möjliga vägar? Föreställ dig hur din "om-då-annan "-kod kommer att växa i den här versionen!

if (option1)
{…}
else if (option2)
{…}
…
else if (optionN) ...

Anta att du har en 10-vägs gaffel i vägen (det är viktigt här att antalet alternativ är begränsat). För sådana situationer har Java switch -satsen.

       switch (ExpressionForMakingAChoice) {
           case (Value1):
               Code1;
               break;
           case (Value2):
               Code2;
               break;
...
           case (ValueN):
               CodeN;
               break;
           default:
               CodeForDefaultChoice;
               break;
       }

Så här fungerar uttalandet:

• ExpressionForMakingAChoice utvärderas. Sedan jämför switch-satsen det resulterande värdet med nästa ValueX (i den ordning som de är listade).
• Om ExpressionForMakingAChoice matchar ValueX, exekveras koden efter kolon.
• Om en break -sats påträffas, överförs kontrollen utanför switch-satsen.
• Om ExpressionForMakingAChoice inte matchar något ValueX, överförs kontrollen till CodeForDefaultCase.

Viktiga punkter

• I switch-satsen måste typen av ExpressionForMakingAChoice vara något av följande:

  • byte , kort , char , int .
  • Byte , Short , Character , Integer (omslag av de primitiva datatyperna).
  • Sträng .
  • Enum .
• Standardblocket är valfritt . Om det saknas och ExpressionForMakingAChoice inte matchar något ValueX, kommer ingen åtgärd att utföras.
• Pausintyget krävs inte . Om den är frånvarande kommer koden att fortsätta att exekveras (om man ignorerar ytterligare jämförelser i fallsatserna) tills den första förekomsten av break eller till slutet av switch -satsen.
• Om samma kod behöver köras för flera val, kan vi eliminera duplicering genom att ange flera på varandra följande fallsatser .

Låt oss nu ta en titt på hur switch-satsen används i Java

Oroa dig inte: vi är klara med teorin. När du ser följande exempel kommer allt att bli mycket tydligare. Nåväl, låt oss börja. Låt oss titta på ett exempel från astronomi som involverar planeterna i vårt solsystem. I enlighet med de senaste internationella attityderna har vi uteslutit Pluto (på grund av dess omloppsbanas egenskaper). Vi minns att våra planeter är ordnade efter deras avstånd från solen enligt följande: Merkurius, Venus, Jorden, Mars, Jupiter, Saturnus, Uranus och Neptunus. Låt oss skriva en Java-metod som tar en planets ordningsnummer (relativt till dess avstånd från solen) och returnerar huvudkomponenterna i planetens atmosfär som en List<String>. Du kommer ihåg att vissa planeter har en liknande atmosfärisk sammansättning. Således innehåller Venus och Mars främst koldioxid; atmosfären hos Jupiter och Saturnus består av väte och helium; och Uranus och Neptunus lägger till metan till det sista gasparet. Här är vår funktion:

public static List<String> getPlanetAtmosphere(int seqNumberFromSun) {
    List<String> result = new ArrayList<>();
    switch (seqNumberFromSun) {
        case 1: result.add("No atmosphere");
            break;
        case 2:
        case 4: result.add("Carbon dioxide");
            break;
        case 3: result.add("Carbon dioxide");
            result.add("Nitrogen");
            result.add ("Oxygen");
            break;
        case 5:
        case 6: result.add("Hydrogen");
            result.add("Helium");
            break;
        case 7:
        case 8: result.add("Methane");
            result.add("Hydrogen");
            result.add("Helium");
            break;
        default:
            break;
    }
    return result;
}

Observera att vi använder samma kod för planeter med identiska atmosfäriska sammansättningar. Vi gjorde detta genom att använda på varandra följande fallbeskrivningar . Om vi ​​vill få sammansättningen av atmosfären på vår hemplanet, kallar vi vår metod med 3 som argument:

getPlanetAtmosphere(3).
System.out.println(getPlanetAtmosphere(3)) returns ["Carbon dioxide", "Nitrogen", "Oxygen"].

Experimentera med break: Vad händer om vi tar bort alla paussatser ? Låt oss ge det ett försök:

    public static List<String> getPlanetAtmosphere(int seqNumberFromSun) {
        List<String> result = new ArrayList<>();
        switch (seqNumberFromSun) {
            case 1: result.add("No atmosphere");
            case 2:
            case 4: result.add("Carbon dioxide");
            case 3: result.add("Carbon dioxide");
                result.add("Nitrogen");
                result.add ("Oxygen");
            case 5:
            case 6: result.add("Hydrogen");
                result.add("Helium");
            case 7:
            case 8: result.add("Methane");
                result.add("Hydrogen");
                result.add("Helium");
            default:
        }
        return result;
    }

Om vi ​​skriver ut resultatet av System.out.println(getPlanetAtmosphere(3)), så finner vi att vår hemplanet inte är så levande. Eller är det? Bedöm själv: ["Koldioxid", "Kväve", "Syre", "Väte", "Helium", "Metan", "Väte", "Helium"] . Varför hände det här? Programmet exekverar alla fallsatser efter den första matchningen till slutet av switchblocket .

Överdriven optimering av paussatser

Observera att vi kan förbättra metoden genom att ordna break- satserna och fallen annorlunda.

public static List<String> getPlanetAtmosphere(int seqNumberFromSun) {
    List<String> result = new ArrayList<>();
    switch (seqNumberFromSun) {
        case 1: result.add("No atmosphere");
                break;
        case 3: result.add("Nitrogen");
                result.add ("Oxygen");
        case 2:
        case 4: result.add("Carbon dioxide");
                break;
        case 7:
        case 8: result.add("Methane");
        case 5:
        case 6: result.add("Hydrogen");
                result.add("Helium");
    }
     return result;
}

Ser ut som mindre kod, eller hur? Vi har minskat det totala antalet uttalanden genom att leka med ordningen på fallutlåtandena och omgruppera dem. Nu läggs varje typ av gas till i listan i endast en kodrad. Koden som ges i det sista exemplet är bara för att visa hur saker fungerar. Vi rekommenderar inte att du skriver kod på det här sättet. Om författaren till sådan Java-kod (låt vara andra programmerare) måste underhålla den, kommer han eller hon att ha mycket svårt att rekonstruera logiken bakom bildandet av dessa fallblock och koden som exekveras i switch- satsen .

Skillnader från if

Med tanke på de yttre likheterna med if- och switch -satser, glöm inte att switch -satsen väljer ett av fallen baserat på ett SPECIFIKT VÄRDE, medan if-satsen kan ha vilket booleskt uttryck som helst. Tänk på detta när du designar din kod.

Slutsats

• Använd case -satsen för mer än två grenar för att inte belamra din kod med if-satser.
• Glöm inte att slutföra grenens logiska block för varje specifikt värde (case-sats) genom att infoga en break- sats.
• Switch - satsens uttryck kan vara en Enum eller String , såväl som vissa primitiva typer.
• Kom ihåg standardblocket . Använd den för att hantera oväntade värden.
• För att optimera prestandan, flytta kodgrenarna som motsvarar de vanligaste värdena till början av switchblocket .
• Låt dig inte ryckas med i din "optimering" genom att ta bort break -satserna i slutet av fallsatserna – sådan kod är svår att förstå, och som ett resultat svår att underhålla.