Оператор switch — это оператор множественного ветвления. Он переключает выполнение на различные части кода программы, основываясь на значении выражения, и часто обеспечивает лучшую альтернативу, чем длинный ряд операторов if-eise-if.

Скачать исходники для статьи можно ниже

Общая форма оператора switch:

switch (expression) {
      case value1:
            // последовательность операторов1
            break;
      case value2:
            // последовательность операторов2
            break;
.
.
.
      case valueN:
            // последовательность операторовN
            break;
      default:
            // последовательность операторов no умолчанию
}

Здесь expression может иметь тип byte, short, int или char; каждое value, указанное в операторах case, должно иметь тип, совместимый с типом выражения. Каждое значение case должно быть уникальной константой (а не переменной). Дублирование значений case недопустимо.
Оператор switch работает следующим образом. Значение выражения сравнивается с каждым из указанных значений в case-операторах. Если соответствие найдено, то выполняется кодовая последовательность, следующая после этого оператора case. Если ни одна из case-констант не соответствует значению выражения, то выполняется оператор default. Однако оператор default необязателен. Если согласующихся case нет, и default не присутствует, то никаких дальнейших действий не выполняется.
Оператор break используется внутри switch, чтобы закончить последовательность операторов. Когда встречается оператор break, выполнение передается к первой строке кода, которая следует за полным оператором switch. Он создает эффект досрочного выхода из switch.
Простой пример, который использует оператор switch:

// Простой пример с оператором switch,
public class SampleSwitch {

  public static void main(String[] args) {
    for (int i = 0; i < 6; i++) {
      switch (i) {
        case 0:
          System.out.println("i равно нулю.");
          break;
        case 1:
          System.out.println("i равно единице.");
          break;
        case 2:
          System.out.println("i равно двум.");
          break;
        case 3:
          System.out.println("i равно трем.");
          break;
        default:
          System.out.println("i больше трех.");
      }
    }
  }
}

Вывод этой программы:

i равно нулю.
i равно единице.
i равно двум.
i равно трем.
i больше трех.
i больше трех.

Не трудно заметить, что на каждом проходе цикла выполняются операторы, связанные с case-меткой, которая соответствует переменной цикла i. Все другие case-ветви обходятся. После того как i становится больше трех, никакого соответствия case-меткам не возникает, поэтому выполняется оператор default.
Оператор break — необязательный. Если он пропускается, выполнение будет продолжено со следующей case-метки. Иногда желательно иметь множественные case-ветви без операторов break между ними. Например, рассмотрим следующую программу:

// switch с пропущенными операторами break,
 
public class MissingBreak {

  public static void main(String args[]) {
    for (int i = 0; i < 12; i++) {
      switch (i) {
        case 0:
        case 1:
        case 2:
        case 3:
        case 4:
          System.out.println("i меньше 5");
          break;
        case 5:
        case 6:
        case 7:
        case 8:
        case 9:
          System.out.println("i меньше 10");
          break;
        default:
          System.out.println("i равно 10 или больше");
      }
    }
  }
}

Эта программа генерирует следующий вывод:
i меньше 5
i меньше 5
i меньше 5
i меньше 5
i меньше 5
i меньше 10
i меньше 10
i меньше 10
i меньше 10
i меньше 10
i равно 10 или больше
i равно 10 или больше

Можно видеть, что выполнение проходит через каждый case, пока не встречается оператор break (или не будет достигнут конец оператора switch).
Хотя предшествующий пример придуман, конечно, ради иллюстрации, пропуск оператора break имеет много практических приложений в реальных программах. Чтобы показать более жизненное использование switch, рассмотрим следующий пример:

public class Switch {

  public static void main(String[] args) {
    int month = 4;
    String season;
    switch (month) {
      case 12:
      case 1:
      case 2:
        season = "Зима";
        break;
      case 3:
      case 4:
      case 5:
        season = "Весна";
        break;
      case 6:
      case 7:
      case 8:
        season = "Лето";
        break;
      case 9:
      case 10:
      case 11:
        season = "Осень";
        break;
      default:
        season = "Непонятный месяц";
    }
    System.out.println("Апрель - это " + season + ".");
  }
}

Вложенные switch-операторы
Вы можете использовать switch как часть последовательности операторов некоторого внешнего switch. Это называется вложенным switch. Так как switch-оператор определяет свой собственный блок, никакие конфликты между case-метками во внутреннем и внешнем switch не возникают. Например, следующий фрагмент совершенно законен:

  switch(count) {
    case 1:
      switch(target) { // вложенный switch
        case 0:
          System.out.println("target равен нулю"); break;
        case 1: // нет конфликтов с внешним switch
          System.out.printIn("target равен единице"); break;
      } break; 
    case 2: // . . .
  }

Здесь утверждение с меткой case 1 во внутреннем switch не находится в противоречии с утверждением case 1 во внешнем switch. Переменная count сравнивается только с case-меткой на внешнем уровне. Если count равна 1, то переменная target сравнивается с внутренней case-меткой. Обратите внимание на три важные особенности оператора switch.

• Switch отличается от if тем, что может проверять только равенство (своей переменной с case-метками), тогда как if может оценивать любой тип булевского выражения. То есть, switch отыскивает только соответствие между значением выражения и одной из его case-меток.
• Никакие две case-метки внутри switch не могут иметь идентичных значений. Однако операторы switch, включенные во внешний switch, могут, конечно, иметь общие case-метки с внутренним switch.
• Оператор switch обычно более эффективен, чем набор вложенных if.