Java Switch-instructie

1. Overzicht

In deze zelfstudie leren we wat de schakelaar verklaring is en hoe deze te gebruiken.

De schakelaar statement stelt ons in staat om meerdere geneste als-anders construeert en verbetert zo de leesbaarheid van onze code.

Schakelaar is in de loop van de tijd geëvolueerd - er zijn nieuwe ondersteunde typen toegevoegd, met name in Java 5 en 7. Het blijft ook evolueren - schakelaar expressies zullen waarschijnlijk worden geïntroduceerd in Java 12.

Hieronder geven we enkele codevoorbeelden om het gebruik van de schakelaar verklaring, de rol van de breken verklaring, de vereisten voor de schakelaar argument/geval waarden en de vergelijking van Draadzonde een knop uitspraak.

Laten we verder gaan met het voorbeeld.

2. Voorbeeld van gebruik

Laten we zeggen, we hebben de volgende genest als-anders uitspraken:

public String exampleOfIF (String animal) {String resultaat; if (animal.equals ("DOG") || animal.equals ("CAT")) {resultaat = "gedomesticeerd dier"; } else if (animal.equals ("TIGER")) {result = "wild dier"; } else {result = "onbekend dier"; } resultaat teruggeven; }

De bovenstaande code ziet er niet goed uit en zou moeilijk te onderhouden en te beredeneren zijn. Om de leesbaarheid te verbeteren kunnen we gebruik maken van een schakelaar verklaring hier:

public String exampleOfSwitch (String animal) {String resultaat; switch (dier) {case "DOG": result = "huisdieren"; breken; case "CAT": resultaat = "huisdier"; breken; case "TIGER": result = "wild dier"; breken; default: result = "onbekend dier"; breken; } resultaat teruggeven; }

Zoals hierboven getoond, vergelijken we de schakelaar argument dier met de verschillende geval waarden. Als geen van de geval waarden is gelijk aan het argument, dan is het blok onder de standaard label wordt uitgevoerd.

Simpel gezegd, de breken instructie wordt gebruikt om een schakelaar uitspraak.

3. Het breken Uitspraak

Hoewel de meeste schakelaar uitspraken in het echte leven impliceren dat slechts een van de geval blokken moeten worden uitgevoerd, de pauze statement is nodig om een schakelaar nadat het blok is voltooid.

Als we vergeten een breken, de blokken eronder worden uitgevoerd.

Om dit aan te tonen laten we de breken statements en voeg de uitvoer toe aan de console voor elk blok:

public String forgetBreakInSwitch (String dier) {schakelaar (dier) {geval "DOG": System.out.println ("gedomesticeerd dier"); standaard: System.out.println ("onbekend dier"); }}

Laten we deze code uitvoeren vergeetBreakInSwitch("HOND"), en controleer de uitvoer om te bewijzen dat alle blokken worden uitgevoerd:

huisdier onbekend dier

Dus we moeten voorzichtig zijn en toevoegen breken instructies aan het einde van elk blok, tenzij het nodig is om door te gaan naar de code onder het volgende label.

Het enige blok waar een breken is niet nodig is de laatste, maar het toevoegen van een breken naar het laatste blok maakt de code minder foutgevoelig.

We kunnen ook profiteren van dit gedrag om weglaten breken wanneer we willen dat dezelfde code wordt uitgevoerd voor verschillende case-instructies. Laten we het voorbeeld in de vorige sectie herschrijven door de eerste 2 gevallen samen te voegen:

public String exampleOfSwitch (String animal) {String resultaat; switch (dier) {case "DOG": case "CAT": result = "huisdieren"; breken; case "TIGER": resultaat = "wild dier"; breken; default: result = "onbekend dier"; breken; } resultaat teruggeven; }

4. schakelaar Argument en geval Waarden

Laten we nu de toegestane soorten schakelaar argument en geval waarden, de vereisten ervoor en hoe de schakelaar statement werkt met Strings.

4.1. Gegevenstypen

We kunnen niet alle soorten objecten en primitieven in de schakelaar uitspraak. EEN schakelaar werkt alleen met vier primitieven en hun wikkels, evenals met de opsommingstype en de Draad klasse:

  • byte en Byte
  • kort en Kort
  • int en Geheel getal
  • char en Karakter
  • opsomming
  • Draad

Draad type is beschikbaar in de schakelaar instructie beginnend met Java 7.

opsomming type is geïntroduceerd in Java 5 en is beschikbaar in het schakelaar verklaring sindsdien.

Wrapper-klassen zijn ook beschikbaar sinds Java 5.

Natuurlijk, schakelaar argument en geval waarden moeten van hetzelfde type zijn.

4.2. Nee nul Waarden

We kunnen de nul waarde als argument voor een schakelaar uitspraak. Als we het doen, zal het programma gooien NullPointerException, met behulp van onze eerste schakelaar voorbeeld:

@Test (verwacht = NullPointerException.class) public void whenSwitchAgumentIsNull_thenNullPointerException () {String animal = null; Assert.assertEquals ("huisdier", s.exampleOfSwitch (dier)); }

We kunnen natuurlijk niet ook passeren nul als een waarde voor de geval label van een schakelaar uitspraak. Als we het doen, zal de code niet compileren.

4.3. Geval Waarden als compilatietijdconstanten

Als we proberen het HOND case waarde met de variabele hond de code zal niet compileren totdat we de hond variabele als laatste:

final String dog = "DOG"; String cat = "CAT"; switch (dier) {case dog: // compileert resultaat = "gedomesticeerd dier"; case cat: // compileert resultaat = "feline"} niet

4.4. Draad Vergelijking

Als een schakelaar -instructie gebruikte de gelijkheidsoperator om strings te vergelijken die we niet konden vergelijken a Draad argument gemaakt met de nieuw operator naar een Draad case waarde correct.

Gelukkig is de schakelaar operator gebruikt de is gelijk aan () methode onder de motorkap.

Laten we dit demonstreren:

@Test public void whenCompareStrings_thenByEqual () {String animal = new String ("DOG"); assertEquals ("huisdier", s.exampleOfSwitch (dier)); }

5. schakelaar Uitdrukkingen

JDK 13 is nu beschikbaar en brengt een verbeterde versie van een nieuwe functie die voor het eerst in JDK 12 werd geïntroduceerd: de schakelaar uitdrukking.

Om het mogelijk te maken, moeten we slagen -Voorbeeld inschakelen naar de compiler.

5.1. De nieuwe schakelaar Uitdrukking

Laten we eens kijken wat het nieuwe is schakelaar uitdrukking ziet eruit als bij het overschakelen naar maanden:

var resultaat = switch (maand) {case JANUARI, JUNI, JULI -> 3; geval FEBRUARI, SEPTEMBER, OKTOBER, NOVEMBER, DECEMBER -> 1; geval MAART, MEI, APRIL, AUGUSTUS -> 2; standaard -> 0; }; 

Een waarde verzenden zoals Maand.JUNE zou zetten resultaat naar 3.

Merk op dat de nieuwe syntaxis de ->operator in plaats van de dubbele punt die we gewend zijn schakelaar verklaringen. Er is ook geen breken trefwoord: het schakelaar expressie valt niet door gevals.

Een andere toevoeging is het feit dat we nu door komma's gescheiden criteria kunnen hebben.

5.2. De opbrengst Trefwoord

Als we een beetje verder gaan, is er een mogelijkheid om fijnmazige controle te krijgen over wat er aan de rechterkant van de uitdrukking gebeurt door codeblokken te gebruiken. In dat geval moeten we het trefwoord gebruiken opbrengst:

var resultaat = switch (maand) {case JANUARI, JUNI, JULI -> 3; geval FEBRUARI, SEPTEMBER, OKTOBER, NOVEMBER, DECEMBER -> 1; geval MAART, MEI, APRIL, AUGUSTUS -> {int monthLength = month.toString (). length (); opbrengst maand Lengte * 4; } standaard -> 0; };

Hoewel ons voorbeeld een beetje willekeurig is, is het punt hier dat we hier toegang hebben tot meer van de Java-taal.

5.3. Binnen terugkomen schakelaar Uitdrukkingen

Als gevolg van het onderscheid tussen schakelaar verklaringen en schakelaar uitdrukkingen, het is mogelijk om terugkeer van binnenuit een schakelaar -verklaring, maar we mogen dit niet doen vanuit een schakelaar uitdrukking.

Het volgende voorbeeld is perfect geldig en zal compileren:

switch (maand) {case JANUARI, JUNI, JULI -> {return 3; } default -> {return 0; }}

De volgende code zal echter niet compileren, zoals we proberen terugkeer buiten een omsluitende schakelaaruitdrukking:

var result = switch (maand) {case JANUARI, JUNI, JULI -> {return 3; } default -> {return 0; }};

5.4. Uitputtend

Tijdens gebruik schakelaar verklaringen, het maakt eigenlijk niet uit of alle gevallen gedekt zijn.

De volgende code is bijvoorbeeld perfect geldig en zal compileren:

switch (maand) {geval JANUARI, JUNI, JULI -> 3; case FEBRUARI SEPTEMBER -> 1; }

Voor schakelaar expressies echter, de compiler dringt erop aan alle mogelijke gevallen zijn gedekt. Het volgende codefragment zou bijvoorbeeld niet compileren, omdat er geen standaardgeval is en niet alle mogelijke gevallen worden gedekt:

var resultaat = switch (maand) {case JANUARI, JUNI, JULI -> 3; case FEBRUARI SEPTEMBER -> 1; }

De schakelaar expressie zal echter geldig zijn wanneer alle mogelijke gevallen zijn afgedekt, zoals in het volgende voorbeeld:

var resultaat = switch (maand) {case JANUARI, JUNI, JULI -> 3; geval FEBRUARI, SEPTEMBER, OKTOBER, NOVEMBER, DECEMBER -> 1; geval MAART, MEI, APRIL, AUGUSTUS -> 2; }

Houd er rekening mee dat het bovenstaande codefragment geen standaard geval. Zolang alle gevallen zijn gedekt, is het schakelaar expressie zal geldig zijn.

6. Conclusie

In deze zelfstudie hebben we de subtiliteiten geleerd van het gebruik van de schakelaar verklaring in Java. We kunnen beslissen of we schakelaar gebaseerd op leesbaarheid en het type van de vergeleken waarden.

De switchverklaring is een goede kandidaat voor gevallen waarin we een beperkt aantal opties hebben in een vooraf gedefinieerde set (bijvoorbeeld: dagen van de week). Anders zouden we de code moeten wijzigen telkens wanneer een nieuwe waarde wordt toegevoegd of verwijderd, wat misschien niet haalbaar is. Voor deze gevallen moeten we andere benaderingen overwegen, zoals polymorfisme of andere ontwerppatronen zoals Command.

Zoals altijd is de volledige JDK 8-code en JDK 13-code beschikbaar op GitHub.