Изявление за превключване на Java

Малко теория за Java Switch

Представете си, че сте рицар, спрял на разклонение на пътя. Ако тръгнеш наляво, ще загубиш коня си. Ако тръгнеш надясно, ще придобиеш знания. Как бихме представor тази ситуация в code? Вероятно вече знаете, че използваме конструкции като if-then и if-then-else, за да вземаме тези решения.

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

Но Howво ще стане, ако пътят се раздели не на две, а на десет? Имате пътища, които са „напълно вдясно“, „малко вляво от това“, „малко повече вляво“ и т.н., общо 10 възможни пътя? Представете си How вашият "if-then-else " code ще расте в тази version!

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

Да предположим, че имате 10-странно разклонение на пътя (тук е важно броят на опциите да е краен). За такива ситуации Java има командата switch .

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

Ето How работи изявлението:

• ExpressionForMakingAChoice се оценява. След това операторът за превключване сравнява получената стойност със следващата ValueX (в реда, в който са изброени).
• Ако ExpressionForMakingAChoice съответства на ValueX, тогава се изпълнява codeът след двоеточието.
• Ако се срещне оператор break , управлението се прехвърля извън оператора switch.
• Ако ExpressionForMakingAChoice не съвпада с никоя ValueX, тогава управлението преминава към CodeForDefaultCase.

Важни точки

• В командата switch типът ExpressionForMakingAChoice трябва да бъде един от следните:

  • byte , short , char , int .
  • Byte , Short , Character , Integer (обвивки на примитивните типове данни).
  • низ .
  • Енум .
• Блокът по подразбиране не е задължителен. Ако липсва и ExpressionForMakingAChoice не съвпада с никоя ValueX, тогава няма да се изпълни ниHowво действие.
• Операторът break не е задължителен. Ако липсва, codeът ще продължи да се изпълнява (пренебрегвайки по-нататъшни сравнения в операторите case) до първото появяване на break or до края на оператора switch .
• Ако един и същ code трябва да бъде изпълнен за няколко избора, можем да елиминираме дублирането, като посочим няколко последователни оператора за case .

Нека сега да разгледаме How операторът switch се използва в Java

Не се притеснявайте: приключихме с теорията. След като видите следните примери, всичко ще стане много по-ясно. Е, да започваме. Нека да разгледаме пример от астрономията, включващ планетите от нашата слънчева система. В съответствие с най-новите международни нагласи, ние изключихме Плутон (поради свойствата на неговата орбита). Припомняме, че нашите планети са подредени според разстоянието им от Слънцето, Howто следва: Меркурий, Венера, Земя, Марс, Юпитер, Сатурн, Уран и Нептун. Нека напишем метод на Java, който взема поредния номер на планетата (спрямо разстоянието й от Слънцето) и връща основните компоненти на атмосферата на планетата като List <String>. Спомняте си, че някои планети имат подобен атмосферен състав. Така Венера и Марс съдържат главно въглероден диоксид; атмосферата на Юпитер и Сатурн се състои от водород и хелий; а Уран и Нептун добавят метан към последната двойка газове. Ето нашата функция:

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

Обърнете внимание, че използваме един и същ code за планети с идентичен атмосферен състав. Направихме това, като използвахме последователни оператори . Ако искаме да получим състава на атмосферата на нашата родна планета, извикваме нашия метод с 3 като аргумент:

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

Експериментирайте с прекъсване: Какво се случва, ако премахнем всички изрази за прекъсване ? Нека да опитаме:

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

Ако отпечатаме резултата от System.out.println(getPlanetAtmosphere(3)) , тогава откриваме, че нашата родна планета не е толкова годна за живеене. Или е така? Преценете сами: ["Въглероден диоксид", "Азот", "Кислород", "Водород", "Хелий", "Метан", "Водород", "Хелий"] . Защо се случи това? Програмата изпълнява всички case оператори след първото съвпадение до края на блока switch .

Прекомерна оптимизация на операторите за прекъсване

Обърнете внимание, че можем да подобрим метода, като подредим операторите за прекъсване и случаите по различен начин.

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

Изглежда по-малко code, нали? Намалихме общия брой изявления, като си поиграхме с реда на изявленията за случаите и ги прегрупирахме. Сега всеки вид газ се добавя към списъка само в един ред code. Кодът, даден в последния пример, е само за да покаже How работят нещата. Не препоръчваме да пишете code по този начин. Ако авторът на такъв code на Java (да не говорим за други програмисти) трябва да го поддържа, той or тя ще намери за много трудно да възстанови логиката зад формирането на тези блокове case и codeа, изпълнен в командата switch .

Разлики от ако

Предвид външните прorки на операторите if и switch , не забравяйте, че операторът switch избира един от случаите въз основа на СПЕЦИФИЧНА СТОЙНОСТ, докато операторът if може да има произволен булев израз. Имайте това предвид, когато проектирате своя code.

Заключение

• Използвайте оператора case за повече от два клона, за да не претрупвате codeа си с оператори if.
• Не забравяйте да завършите логическия блок на разклонението за всяка конкретна стойност (case оператор), като вмъкнете break оператор.
• Изразът на оператора switch може да бъде Enum or String , Howто и някои примитивни типове.
• Запомнете блока по подразбиране . Използвайте го за обработка на неочаквани стойности.
• За да оптимизирате производителността, преместете codeовите разклонения, съответстващи на най-често срещаните стойности, в началото на блока за превключване .
• Не се увличайте във вашата „оптимизация“, като изтриете операторите за прекъсване в края на операторите за case – такъв code е труден за разбиране и, в резултат на това, труден за поддръжка.