Pahayag ng Java switch

Isang kaunting teorya tungkol sa Java Switch

Isipin na ikaw ay isang kabalyero na huminto sa isang sangang bahagi ng kalsada. Kung pupunta ka sa kaliwa, mawawala ang iyong kabayo. Kung tama ka, magkakaroon ka ng kaalaman. Paano natin kakatawanin ang sitwasyong ito sa code? Marahil ay alam mo na na gumagamit kami ng mga konstruksyon tulad ng if-then at if-then-else para gawin ang mga desisyong ito.

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?");

Ngunit paano kung ang kalsada ay nahati hindi sa dalawa, ngunit sa sampu? Mayroon kang mga kalsada na "ganap sa kanan", "bahagyang pakaliwa niyan", "medyo pakaliwa" at iba pa, na may kabuuang 10 posibleng kalsada? Isipin kung paano lalago ang iyong "if-then-else " code sa bersyong ito!

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

Ipagpalagay na mayroon kang 10-way na tinidor sa kalsada (mahalaga dito na ang bilang ng mga opsyon ay may hangganan). Para sa mga ganitong sitwasyon, may switch statement ang Java.

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

Ganito gumagana ang pahayag:

• Nasusuri ang ExpressionForMakingAChoice. Pagkatapos, inihahambing ng switch statement ang resultang value sa susunod na ValueX (sa pagkakasunud-sunod kung saan nakalista ang mga ito).
• Kung ang ExpressionForMakingAChoice ay tumutugma sa ValueX, ang code na sumusunod sa colon ay isasagawa.
• Kung nakatagpo ng break statement, ililipat ang kontrol sa labas ng switch statement.
• Kung ang ExpressionForMakingAChoice ay hindi tumutugma sa anumang ValueX, pagkatapos ay ang control pass sa CodeForDefaultCase.

Mahalagang puntos

• Sa switch statement, ang uri ng ExpressionForMakingAChoice ay dapat isa sa mga sumusunod:

  • byte , maikli , char , int .
  • Byte , Short , Character , Integer (mga wrapper ng primitive datatypes).
  • String .
  • Enum .
• Ang default na bloke ay opsyonal. Kung wala ito at ang ExpressionForMakingAChoice ay hindi tumutugma sa anumang ValueX, walang aksyon na isasagawa.
• Ang pahayag ng break ay hindi kinakailangan. Kung wala ito, ang code ay patuloy na isasagawa (binabalewala ang mga karagdagang paghahambing sa mga pahayag ng kaso) hanggang sa unang paglitaw ng break o hanggang sa katapusan ng switch statement.
• Kung ang parehong code ay kailangang isagawa para sa ilang mga pagpipilian, maaari naming alisin ang pagdoble sa pamamagitan ng pagtukoy ng ilang magkakasunod na pahayag ng kaso .

Tingnan natin ngayon kung paano ginagamit ang switch statement sa Java

Huwag kang mag-alala: tapos na tayo sa teorya. Pagkatapos mong makita ang mga sumusunod na halimbawa, magiging mas malinaw ang lahat. Well, simulan na natin. Tingnan natin ang isang halimbawa mula sa astronomiya na kinasasangkutan ng mga planeta ng ating solar system. Alinsunod sa mga pinakabagong pang-internasyonal na saloobin, ibinukod namin ang Pluto (dahil sa mga katangian ng orbit nito). Naaalala natin na ang ating mga planeta ay nakaayos ayon sa kanilang distansya mula sa Araw tulad ng sumusunod: Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus at Neptune. Sumulat tayo ng Java method na kumukuha ng ordinal number ng planeta (na may kaugnayan sa distansya nito mula sa Araw) at ibinabalik ang mga pangunahing bahagi ng atmospera ng planeta bilang List <String>. Maaalala mo na ang ilang mga planeta ay may katulad na komposisyon sa atmospera. Kaya, ang Venus at Mars ay naglalaman ng pangunahing carbon dioxide; ang kapaligiran ng Jupiter at Saturn ay binubuo ng hydrogen at helium; at ang Uranus at Neptune ay nagdaragdag ng methane sa huling pares ng mga gas. Narito 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;
}

Tandaan na ginagamit namin ang parehong code para sa mga planeta na may magkaparehong komposisyon sa atmospera. Ginawa namin ito sa pamamagitan ng paggamit ng magkakasunod na case statement. Kung gusto nating makuha ang komposisyon ng atmospera ng ating planeta, tinatawag natin ang ating pamamaraan na may 3 bilang argumento:

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

Eksperimento sa break: Ano ang mangyayari kung aalisin namin ang lahat ng pahayag ng break ? Subukan Natin:

    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 namin ang resulta ng System.out.println(getPlanetAtmosphere(3)) , makikita namin na ang aming planetang tahanan ay hindi masyadong mabubuhay. O kaya naman? Maghusga para sa iyong sarili: ["Carbon dioxide", "Nitrogen", "Oxygen", "Hydrogen", "Helium", "Methane", "Hydrogen", "Helium"] . Bakit nangyari ito? Isinasagawa ng programa ang lahat ng case statement pagkatapos ng unang tugma hanggang sa katapusan ng switch block.

Labis na pag-optimize ng mga pahayag ng break

Tandaan na maaari naming pagbutihin ang pamamaraan sa pamamagitan ng pag-aayos ng mga pahayag ng break at mga kaso nang naiiba.

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 kaunting code, tama? Binawasan namin ang kabuuang bilang ng mga pahayag sa pamamagitan ng paglalaro sa pagkakasunud-sunod ng mga pahayag ng kaso at muling pagpapangkat sa mga ito. Ngayon ang bawat uri ng gas ay idinagdag sa listahan sa isang linya lamang ng code. Ang code na ibinigay sa huling halimbawa ay para lamang ipakita kung paano gumagana ang mga bagay. Hindi namin inirerekomenda ang pagsulat ng code sa ganitong paraan. Kung ang may-akda ng naturang Java code (pabayaan ang iba pang mga programmer) ay dapat na panatilihin ito, mahihirapan siyang muling buuin ang lohika sa likod ng pagbuo ng mga bloke ng kaso at ang code na naisakatuparan sa switch statement .

Mga pagkakaiba sa kung

Dahil sa mga panlabas na pagkakatulad ng if at switch statement, huwag kalimutan na ang switch statement ay pumipili ng isa sa mga case batay sa isang SPECIFIC VALUE, samantalang ang if statement ay maaaring magkaroon ng anumang boolean expression. Isaisip ito kapag nagdidisenyo ng iyong code.

Konklusyon

• Gamitin ang case statement para sa higit sa dalawang sangay upang hindi kalat ang iyong code ng mga if statement.
• Huwag kalimutang kumpletuhin ang lohikal na bloke ng sangay para sa bawat partikular na halaga (case statement) sa pamamagitan ng pagpasok ng break statement.
• Ang expression ng switch statement ay maaaring isang Enum o String , pati na rin ang ilang primitive na uri.
• Tandaan ang default na bloke. Gamitin ito upang pangasiwaan ang mga hindi inaasahang halaga.
• Upang i-optimize ang pagganap, ilipat ang mga sangay ng code na naaayon sa mga pinakakaraniwang halaga sa simula ng switch block.
• Huwag madala sa iyong "pag-optimize" sa pamamagitan ng pagtanggal sa mga pahayag ng break sa dulo ng mga pahayag ng kaso – ang naturang code ay mahirap maunawaan, at, bilang resulta, mahirap panatilihin.