Lidt teori om Java Switch
Forestil dig, at du er en ridder, der stoppes ved en gaffel i vejen. Hvis du går til venstre, mister du din hest. Hvis du går rigtigt, får du viden. Hvordan vil vi repræsentere denne situation i kode? Du ved sikkert allerede, at vi bruger konstruktioner som hvis-så og hvis-så-andet til at træffe disse beslutninger.
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 hvad nu hvis vejen ikke deler sig i to, men i ti? Du har veje, der er "helt til højre", "lidt til venstre for det", "en lille smule mere til venstre" og så videre, i alt 10 mulige veje? Forestil dig, hvordan din "hvis-så-andet "-kode vil vokse i denne version!
if (option1)
{…}
else if (option2)
{…}
…
else if (optionN) ...
Antag, at du har en 10-vejs gaffel i vejen (det er vigtigt her, at antallet af muligheder er begrænset). Til sådanne situationer har Java switch -sætningen.
switch (ExpressionForMakingAChoice) {
case (Value1):
Code1;
break;
case (Value2):
Code2;
break;
...
case (ValueN):
CodeN;
break;
default:
CodeForDefaultChoice;
break;
}
Sådan fungerer udsagnet:
- ExpressionForMakingAChoice evalueres. Derefter sammenligner switch-sætningen den resulterende værdi med den næste ValueX (i den rækkefølge, de er anført).
- Hvis ExpressionForMakingAChoice matcher ValueX, udføres koden efter kolon.
- Hvis der stødes på en break- sætning, overføres kontrol uden for switch-sætningen.
- Hvis ExpressionForMakingAChoice ikke matcher nogen ValueX, overføres kontrollen til CodeForDefaultCase.
-
I switch-sætningen skal typen af ExpressionForMakingAChoice være en af følgende:
- byte , kort , char , int .
- Byte , Short , Character , Integer (omslag af de primitive datatyper).
- String .
- Enum .
- Standardblokken er valgfri . Hvis den er fraværende, og ExpressionForMakingAChoice ikke matcher nogen ValueX, vil der ikke blive udført nogen handling.
- Pauseerklæringen er ikke påkrævet . Hvis den er fraværende, vil koden fortsætte med at blive eksekveret (ignorerer yderligere sammenligninger i case-sætningerne) indtil den første forekomst af break eller indtil slutningen af switch- sætningen.
- Hvis den samme kode skal udføres for flere valg, kan vi eliminere duplikering ved at angive flere på hinanden følgende case -sætninger.
Lad os nu tage et kig på, hvordan switch-sætningen bruges i Java
Bare rolig: vi er færdige med teorien. Når du har set følgende eksempler, vil alt blive meget klarere. Nå, lad os komme i gang. Lad os se på et eksempel fra astronomi, der involverer planeterne i vores solsystem. I overensstemmelse med de seneste internationale holdninger har vi udelukket Pluto (på grund af egenskaberne ved dens kredsløb). Vi husker, at vores planeter er arrangeret efter deres afstand fra Solen som følger: Merkur, Venus, Jorden, Mars, Jupiter, Saturn, Uranus og Neptun. Lad os skrive en Java-metode, der tager en planets ordenstal (i forhold til dens afstand fra Solen) og returnerer hovedkomponenterne i planetens atmosfære som en List<String>. Du vil huske, at nogle planeter har en lignende atmosfærisk sammensætning. Venus og Mars indeholder således hovedsageligt kuldioxid; atmosfæren i Jupiter og Saturn består af brint og helium; og Uranus og Neptun tilføjer metan til det sidste par gasser. Her er vores 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;
}
Bemærk, at vi bruger den samme kode for planeter med identiske atmosfæriske sammensætninger. Det gjorde vi ved at bruge fortløbende sagsfremstillinger . Hvis vi ønsker at få sammensætningen af atmosfæren på vores hjemmeplanet, kalder vi vores metode med 3 som argument:
getPlanetAtmosphere(3).
System.out.println(getPlanetAtmosphere(3)) returns ["Carbon dioxide", "Nitrogen", "Oxygen"].
Eksperimenter med break: Hvad sker der, hvis vi fjerner alle break- udsagn? Lad os prøve det:
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;
}
Hvis vi udskriver resultatet af System.out.println(getPlanetAtmosphere(3)) , så finder vi ud af, at vores hjemmeplanet ikke er så beboelig. Eller er det? Døm selv: ["Kuldioxid", "Nitrogen", "Oxygen", "Brint", "Helium", "Metan", "Brint", "Helium"] . Hvorfor skete dette? Programmet udfører alle case- sætninger efter den første match indtil slutningen af switch- blokken.
Overdreven optimering af pauseerklæringer
Bemærk, at vi kan forbedre metoden ved at arrangere break- udsagn og sager forskelligt.
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;
}
Det ligner mindre kode, ikke? Vi har reduceret det samlede antal erklæringer ved at lege med rækkefølgen af sagserklæringerne og omgruppere dem. Nu føjes hver type gas til listen i kun én kodelinje. Koden givet i det sidste eksempel er kun for at vise, hvordan tingene fungerer. Vi anbefaler ikke at skrive kode på denne måde. Hvis forfatteren af en sådan Java-kode (endsige andre programmører) skal vedligeholde den, vil han eller hun finde det meget vanskeligt at rekonstruere logikken bag dannelsen af disse case-blokke og koden, der udføres i switch- sætningen .
Forskelle fra if
I betragtning af de ydre ligheder mellem if og switch- sætninger, glem ikke, at switch- sætningen vælger et af tilfældene baseret på en SPECIFIK VÆRDI, hvorimod if-sætningen kan have et hvilket som helst boolesk udtryk. Husk dette, når du designer din kode.Konklusion
- Brug case -sætningen til mere end to grene for ikke at fylde din kode med if-sætninger.
- Glem ikke at fuldføre den logiske blok af grenen for hver specifik værdi (case statement) ved at indsætte en break -sætning.
- Switch - sætningens udtryk kan være en Enum eller String samt nogle primitive typer.
- Husk standardblokken . Brug den til at håndtere uventede værdier.
- For at optimere ydeevnen skal du flytte kodegrenene svarende til de mest almindelige værdier til begyndelsen af omskifterblokken .
- Lad dig ikke rive med i din "optimering" ved at slette break- sætningerne i slutningen af case- udsagnene – sådan kode er svær at forstå, og som følge heraf svær at vedligeholde.
GO TO FULL VERSION