Lumipat ng pahayag sa Java

Isipin na ikaw ay nakatayo sa isang tinidor, tulad ng isang bayani mula sa isang sikat na pagpipinta. Kung pupunta ka sa kaliwa, mawawala ang iyong kabayo; kung pupunta ka sa kanan, magkakaroon ka ng kaalaman. Paano i-program ang ganitong sitwasyon? Malamang na alam mo na na gumagawa kami ng ganoong pagpipilian gamit ang if-then at if-then-else constructs .

if (turn_left) {
    System.out.println(«Коня потеряешь»);
}
if (turn_right) {
    System.out.println(“Знания обретёшь”);
}
else
    System.out.println(“Так и будешь стоять?”);

Paano kung walang dalawang ganoong track, ngunit 10? Mayroon bang landas "sa kanan", "kaunti sa kaliwa", "kaunti pa sa kaliwa" at iba pa, sa halagang 10 piraso? Isipin kung paano lalago ang iyong if-then-else code sa bersyong ito!

if (вариант1)
{… }
else if (вариант2)
{…}
…
else if (вариантN) ….

Kaya, wala kang isang tinidor ng mga kundisyon, ngunit marami, sabihin, 10 (ang mahalagang bagay dito ay ang bilang ng mga tinidor ay limitado). Para sa mga ganitong sitwasyon, mayroong isang espesyal na operator ng pagpili - switch case java .

switch (ВыражениеДляВыбора) {
           case  (Значение1):
               Код1;
               break;
           case (Значение2):
               Код2;
               break;
...
           case (ЗначениеN):
               КодN;
               break;
           default:
               КодВыбораПоУмолчанию;
               break;
       }

Ang utos ng pagpapatupad sa pahayag ay ang mga sumusunod:

• Ang SelectionExpression ay sinusuri. Susunod, inihahambing ng switch statement ang nagresultang expression sa susunod na Value (sa pagkakasunud-sunod na nakalista).
• Kung ang SelectExpression ay tumutugma sa Value, ang code na sumusunod sa colon ay isasagawa.
• Kung ang break construct ay nakatagpo , pagkatapos ay ang kontrol ay ililipat sa labas ng switch command.
• Kung walang nakitang mga tugma sa pagitan ng ExpressionForSelection at Values, pagkatapos ay ililipat ang kontrol sa DefaultSelectionCode.

Mahalagang puntos

• Ang SelectionExpression type para sa switch selection statement sa Java ay dapat isa sa mga sumusunod:

  • byte , maikli , char , int .
  • Ang kanilang mga balot ay Byte , Short , Character , Integer .
  • String (mula noong Java 7).
  • Enumerasyon ( Enum ).
• Opsyonal ang default na bloke , kung gayon kung hindi magkatugma ang SelectionExpression at Values, walang aksyon na gagawin.
• Ang break ay opsyonal; kung wala ito, ang code ay magpapatuloy sa pagpapatupad (hindi papansinin ang mga karagdagang paghahambing ng mga halaga sa mga bloke ng kaso) hanggang sa ang unang breakpahayag ng switch ay nakatagpo o hanggang sa katapusan.
• kung kinakailangan na isagawa ang parehong code para sa ilang mga pagpipilian sa pagpili, upang maiwasan ang pagdoble ay ipinapahiwatig namin ang ilang kaukulang mga halaga sa harap nito sa magkakasunod na mga bloke ng kaso .

Lumipat tayo sa kasanayan ng paggamit ng switch statement sa Java

Huwag mag-alala, tapos na tayo sa teorya, at pagkatapos ng karagdagang mga halimbawa ay magiging mas malinaw ang lahat. Kaya simulan na natin. Tingnan natin ang isang halimbawa mula sa astronomiya tungkol sa mga planeta ng solar system. Alinsunod sa mga pinakabagong internasyonal na regulasyon, ibubukod namin ang Pluto (dahil sa mga katangian ng orbit nito). Tandaan natin na ang ating mga planeta ay matatagpuan mula sa Araw sa sumusunod na pagkakasunod-sunod: Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus at Neptune. Gumawa tayo ng isang pamamaraan ng Java na tumatanggap bilang input ng serial number ng planeta (na may kaugnayan sa distansya mula sa Araw), at bilang isang output ay gumagawa ng pangunahing komposisyon ng atmospera ng planetang ito sa anyo ng isang List <String> . Hayaan akong ipaalala sa iyo na ang ilang mga planeta ay may katulad na komposisyon sa kapaligiran. Kaya, ang Venus at Mars ay pangunahing naglalaman ng carbon dioxide, ang Jupiter at Saturn ay binubuo ng hydrogen at helium, at ang Uranus at Neptune, bilang karagdagan sa huling pares ng mga gas, ay mayroon ding methane. Ang aming function:

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

Pakitandaan: inihambing namin ang parehong code sa mga planeta na may magkaparehong komposisyon sa atmospera. At ginawa namin ito sa pamamagitan ng paggamit ng magkakasunod na case constructions . Kaya, kung nais nating makuha ang komposisyon ng kapaligiran ng ating planeta sa tahanan, tinatawag natin ang ating pamamaraan na may parameter 3:

getPlanetAtmosphere(3).
System.out.println(getPlanetAtmosphere(3)) вернет нам [Углекислый газ, Азот, Кислород].

Eksperimento sa break Ano ang mangyayari kung aalisin namin ang lahat ng break statement ? Subukan natin ito sa pagsasanay:

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

Kung ipi-print natin ang resulta ng pamamaraan System.out.println(getPlanetAtmosphere(3)), kung gayon ang ating planeta sa tahanan ay hindi magiging angkop para sa buhay. O angkop? Maghusga para sa iyong sarili: [Carbon dioxide, Nitrogen, Oxygen, Hydrogen, Helium, Methane, Hydrogen, Helium], Bakit ito nangyari? Ang programa ay nagsagawa ng lahat ng mga kaso pagkatapos ng unang tugma at hanggang sa katapusan ng switch block.

Sobrang optimization break

Tandaan na maaari naming pagbutihin ang pamamaraan na may ibang pagsasaayos ng mga direktiba ng break at mga pagpipilian sa pagpili

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

Mukhang mas maikli, hindi ba? Binawasan namin ang kabuuang bilang ng mga pahayag sa pamamagitan ng paglalaro sa pagkakasunud-sunod ng kaso at muling pagpapangkat. Ngayon ang bawat uri ng gas ay idinagdag sa listahan sa isang linya lamang ng code. Ang listahan ng huling halimbawa ng pamamaraan ay ipinapakita lamang upang ipakita ang gawain; lubos na hindi inirerekomenda na magsulat sa ganoong istilo. Kung ang may-akda (at higit pa sa mga third-party na programmer) ng katulad na code ay kailangang panatilihin ito, kung gayon magiging napakahirap na ibalik ang lohika para sa pagbuo ng mga bloke ng pagpili at maipapatupad na code para sa pahayag ng java switch.

Mga pagkakaiba sa kung

Habang ang mga pahayag ng if at switch ay magkatulad sa hitsura , huwag kalimutan na ang multiple choice operator switch ay nakabatay sa pagpili ng mga opsyon sa pagpapatupad sa isang SPECIFIC VALUE, samantalang sa if. maaaring maging anumang lohikal na pagpapahayag. Isaalang-alang ang katotohanang ito kapag nagdidisenyo ng iyong code. Tingnan natin ang mga inobasyon para sa switch sa iba't ibang bersyon ng Java.

Lumipat sa Java 7

Bago ang Java 7, maaaring gamitin ang mga byte, short, char at int primitive bilang value para sa isang switch. Nagkaroon din ng suporta para sa enum at mga wrapper ng mga primitive na uri na nakalista sa itaas: Character, Byte, Short, at Integer. Ngunit madalas kailangan nating hanapin ang halaga ng isang java switch string! Ito ang magiging hitsura nito sa Java 6:

DayOfWeek day = DayOfWeek.fromValue("Thursday");

switch (day) {
  case MONDAY:
     System.out.println("Today is windy !");
     break;
  case THURSDAY:
     System.out.println("Today is sunny !");
     break;
  case WEDNESDAY:
     System.out.println("Today is rainy!");
     break;
  default:
     System.out.println("Oooops, something wrong !");

At enum:

public enum DayOfWeek {
  MONDAY("Monday"),
  THURSDAY("Thursday"),
  WEDNESDAY("Wednesday"),
  NOT_FOUND("Not found");

  private final String value;

  DayOfWeek(final String value) {
     this.value = value;
  }

  public static DayOfWeek fromValue(String value) {
     for (final DayOfWeek dayOfWeek : values()) {
        if (dayOfWeek.value.equalsIgnoreCase(value)) {
           return dayOfWeek;
        }
     }
     return NOT_FOUND;
  }
}

Ngunit simula sa Java 7, posible na gamitin ang uri ng String bilang isang halaga para sa isang switch:

String day = "Thursday";

switch (day) {
  case "Monday":
     System.out.println("Today is windy !");
     break;
  case "Thursday":
     System.out.println("Today is sunny !");
     break;
  case "Wednesday":
     System.out.println("Today is rainy!");
     break;
  default:
     System.out.println("Oooops, something wrong !");
}

Sa kabila ng mga bagong feature, ang diskarte gamit ang enum ay mas nababaluktot at inirerekomenda para sa paggamit: maaari naming muling gamitin ang enum na ito nang maraming beses.

Lumipat sa Java 12

Pinahusay ng Java 12 ang mga expression ng Switch para sa pagtutugma ng pattern. Kung gagamitin namin ang Switch tulad ng sa halimbawa sa itaas, upang itakda ang halaga ng ilang variable, kinailangan naming kalkulahin ang halaga at italaga ito sa ibinigay na variable, at pagkatapos ay gumamit ng break:

int count = 2;
int value;
switch (count) {
  case 1:
     value = 12;
     break;
  case 2:
     value = 32;
     break;
  case 3:
     value = 52;
     break;
  default:
     value = 0;
}

Ngunit salamat sa mga kakayahan ng Java 12, maaari naming muling isulat ang expression na ito tulad ng sumusunod:

int value = switch (count) {
  case 1:
     break 12;
  case 2:
     break 32;
  case 3:
     break 52;
  default:
     break 0;
};

Balikan natin nang kaunti ang mga pagbabago:

1. Kung dati ay nagtakda kami ng isang variable na halaga sa loob ng mga bloke ng kaso, dahil ang switch statement mismo ay walang maibabalik na anuman, ngayon ay mayroon kaming ganoong pagkakataon, at direkta naming ibinabalik ang halaga gamit ang switch.

2. Dati, wala na kaming anumang bagay sa kanan ng break, ngunit ngayon ginagamit namin ito bilang return statement upang ibalik ang halaga ng aming switch. Markahan ng colon mark ang entry point sa isang statement block. Ibig sabihin, mula sa puntong iyon ay magsisimula ang pagpapatupad ng lahat ng code sa ibaba, kahit na may nakasalubong na ibang label.

   Ang resulta ay isang end-to-end na paglipat mula sa marka patungo sa marka, na tinatawag ding fall -through.

Upang makumpleto ang naturang pass, dapat mong ipasa ang lahat ng mga elemento nang buo, o gumamit ng break o return. Ang inobasyon sa java 12 ay nagbibigay sa amin ng kakayahang gamitin ang lambda operator, na siya namang tinitiyak na tanging ang code sa kanan nito ang isasagawa. Nang walang anumang "pagkabigo". Ano ang magiging hitsura ng nakaraang halimbawa sa kasong ito:

int count = 2;
int value = switch (count) {
  case 1 -> 12;
  case 2 -> 32;
  case 3 -> 52;
  default -> 0;
};

Ang code ay naging mas simple, hindi ba? At isa pang bagay: ang operator ng lambda ay maaari ding magsilbi bilang isang tipikal na analogue ng isang colon, pagkatapos ay mayroong isang buong bloke na may ilang mga operasyon:

int count = 2;
int value = switch (count) {
  case 1 -> {
     //some computational operations...
     break 12;
  }
  case 2 -> {
     //some computational operations...
     break 32;
  }
  case 3 -> {
     //some computational operations...
     break 52;
  }
  default -> {
     //some computational operations...
     break 0;
  }
};

Well, paano kung para sa ilang mga kaso ang return value ay pareho? Lumalabas na mayroon kaming parehong mga kaso para sa ilang magkakaibang mga halaga. Narito kung paano ito maaaring paikliin gamit ang mga bagong feature sa Java 12:

int count = 2;
int value = switch (count) {
  case 1, 3, 5 -> 12;
  case 2, 4, 6 -> 52;
  default -> 0;
};

Lumipat sa Java 13

Sa Java 13, ang paraan ng pagbabalik ng isang switch sa isang halaga ay nagbago. Kung sa java 12 isinulat namin ang return value pagkatapos ng break, na nagsilbing return para sa amin para sa switch block, ngayon ay ibabalik namin ang value gamit ang salitang yield . Tingnan natin:

int value = switch (count) {
  case 1:
     yield 12;
  case 2:
     yield 32;
  case 3:
     yield 52;
  default:
     yield 0;
};

Kasabay nito, ang code na nakasulat sa java 12 gamit ang break to return ay hindi mag-compile (( Break ay gagamitin, ngunit sa mga sitwasyon kung saan hindi namin kailangang ibalik ang anuman.

Kabuuan

• Gamitin ang case statement kapag mayroong higit sa dalawang sangay upang maiwasan ang pagkalat ng iyong code sa mga istrukturang if.
• Huwag kalimutang tapusin ang lohikal na bloke ng bawat sangay na tumutugma sa isang partikular na halaga (case block) na may break na tawag .
• Bilang karagdagan sa ilang primitive na uri, ang switch statement ay maaari ding gumamit ng Enum at String na mga uri bilang mga expression .
• Tandaan ang default na block - gamitin ito upang pangasiwaan ang mga hindi planadong value ng pagpili.
• Para ma-optimize ang performance, ilipat ang mga sangay ng code na may pinakakaraniwang mga pagpipilian sa simula ng switch block.
• Huwag madala sa "pag-optimize" sa pamamagitan ng pag-alis ng pahinga sa dulo ng bloke ng pagpili ng kaso - ang naturang code ay mahirap maunawaan, at, bilang resulta, mahirap mapanatili sa panahon ng pagbuo nito.