Цикл статей «Учебник Java 8».
Следующая статья — «Пакеты в Java 8».
Предыдущая статья — «Java 8 выражения, инструкции и блоки».
Инструкции (операторы) в программе выполняются сверху вниз по исходному файлы. Операторы управления порядком выполнения позволяют прервать обычный ход выполнения, позволив выполнить один кусок кода несколько раз, выполнить кусок кода только при выполнении определённого условия.
Содержание
Оператор if-then и if-then-else
Оператор switch
Оператор while
Оператор do-while
Оператор for
Оператор break
Оператор continue
Оператор return
Оператор if-then и if-then-else
Оператор if-then / if-then-else позволяет выполнить один оператор или блок операторов только при выполнении определённого условия. Он имеет две формы. Форма if-then позволяет выполнить кусок кода при выполнении определённого условия, а форма if-then-else в дополнение к этому позволяет ещё указать кусок кода, который будет выполняться при НЕвыполнении этого условия.
Синтаксис if-then для куска кода из одного оператора:
1 2 |
if (<выражение_boolean>) <оператор1>; |
Синтаксис if-then для блока операторов:
1 2 3 4 5 6 |
if (<выражение_boolean>) { <оператор1>; <оператор2>; ... <операторN>; } |
Оператор if-then выполняется так:
- Вычисляется результат выражения <выражение_boolean> , которое должно обязательно вернуть тип boolean.
- Если выражение <выражение_boolean> вернуло true, то выполняется <оператор1> для случая с одним оператором и <оператор1> , <оператор2> , … <операторN> для случая блока операторов.
Примеры:
1 2 |
if (isCracked) System.out.println("Cracked"); |
1 2 3 4 |
if (isCracked) { System.out.println("In block"); System.out.println("Cracked"); } |
Согласно официальному соглашения о кодировании рекомендуется всегда использовать блок операторов, даже если оператор только один. Пример:
1 2 3 |
if (isCracked) { System.out.println("Cracked"); } |
Синтаксис if-then-else :
1 2 3 4 |
if (<выражение_boolean>) <оператор1>; else <оператор2>; |
1 2 3 4 5 6 7 |
if (<выражение_bolean>) { <оператор_then_1>; <оператор_then_3>; ... <оператор_then_N>; } else <оператор_else_1>; |
1 2 3 4 5 6 7 8 |
if (<выражение_bolean>) <оператор_then_1>; else { <оператор_else_1>; <оператор_else_2>; ... <оператор_else_N>; } |
1 2 3 4 5 6 7 8 9 10 11 |
if (<выражение_bolean>) { <оператор_then_1>; <оператор_then_3>; ... <оператор_then_N>; } else { <оператор_else_1>; <оператор_else_2>; ... <оператор_else_N>; } |
Работает он так:
- Если <выражение_boolean> вернуло true, то выполняется оператор или блок операторов внутри фигурных скобок, как и для if-then.
- Если <выражение_boolean> вернуло false, то выполняется оператор или блок операторов в else.
Примеры:
1 2 3 4 5 |
if (isCracked) { System.out.println("Cracked"); } else { System.out.println("not cracked"); } |
1 2 3 4 |
if (isCracked) System.out.println("Cracked"); else System.out.println("not cracked"); |
Согласно соглашению о кодировании нужно всегда использовать вариант с блоком операторов (инструкций), даже если оператор только один, не смотря на то что компилятор позволяет в любом из кусков кода then и else использовать вариант с одним оператором и с блоком.
Можно в блоке else проверить другое условие, тогда получится конструкция вида:
1 2 3 4 5 6 7 8 9 |
if (x < 0) { System.out.println("< 0"); } else if (x == 3) { System.out.println(" == 3"); } else if (x > 10) { System.out.println(" > 10"); } else { System.out.println("else (x >= 0 and x <> 3 and x <= 10)"); } |
В конструкциях такого вида будет сначала проверяться условие в первом if (в данном случае x < 0 ), если оно вернёт true, то выполнится его блок, если оно вернёт false, то будет проверяться следующее условие (в данном случае x == 3 ), если оно вернёт true, то выполнится его блок. Таким образом будут проверяться подряд все условия до такого условия, которое вернёт true. Если же ни одно из условий не вернёт true, то выполнится блок else (если он есть, но его может не быть, тогда управление перейдёт дальше к следующему оператору за такой конструкцией).
Обратите внимание, что <выражение_boolean> может быть абсолютно любым выражением, возвращающим boolean, можно использовать даже операцию присвоения переменной логического типа, так как операция присвоения тоже возвращает значение:
1 2 3 4 5 6 7 8 9 |
boolean b; int x = 3; if (b = x > 0) { // Теперь b присвоено true, как результат метода // obj1.someMethodReturnsBoolean() } else { // А вот здесь b присвоено false. } |
Однако согласно соглашению о кодировании в Java использовать подобную возможность не стоит.
Оператор switch
Рассмотрим следующий кусок кода:
1 2 3 4 5 6 7 8 9 |
if (mode == 0) { // operators for mode 0 } else if (mode == 1) { // operators for mode 1 } else if (mode == 2) { // operators for mode 2 } else { // operators for other mode. } |
В куске кода, приведённом выше, проверяется значение переменной mode. Для значений 0, 1 и 2 предусмотрены отдельные блоки кода, и ещё один блок кода предусмотрен для всех остальных значений. Оператор switch делает то же самое, но делает код более наглядным:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
switch (mode) { case 0: // operators for mode 0 break; case 1: // operators for mode 1 break; case 2: // operators for mode 2 break; default: // operators for other mode break; } |
Этот кусок кода с оператором switch делает абсолютно то же самое, что и кусок кода с if, рассмотренный до этого, но рекомендуется использовать вариант со switch, так как он более нагляден.
Оператор switch работает в следующем порядке:
- Вычисляется выражение в скобках (в данном примере оно состоит просто из переменной mode )
- Полученное значение проверяется подряд со значениями в case , и выполняется тот блок операторов, который относится к case со значением, совпадающим со значением выражения.
- Если ни одно из значений не совпало, то выполняется блок default.
- По ключевому слову break выполнение блока внутри case или default завершается и управление передаётся на следующую инструкцию за блоком switch.
С помощью if-then и if-then-else можно проверять любые условия, но с помощью switch можно проверять только значения выражений типа byte , short , char , int , перечисления (будет описано позднее), String (начиная с Java SE 7), а также классы java.lang.Byte , java.lang.Short , java.langCharacter , java.lang.Integer. Проверяемые значения в case обязательно должны быть константными литералами. Если значение выражения в switch равно null, то возникает java.lang.NullPointerException. Нагляднее всего switch выглядит именно с перечислениями.
Ключевое слово break не обязательно. В случае его отсутствия по завершении выполнения блока операторов внутри одного case выполняются операторы следующего за ним case. Это позволяет использовать один блок операторов для нескольких значений case:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
switch (mode) { case -1: System.out.println("mode -1"); break; case 0: System.out.println("mode 0"); case 1: case 2: System.out.println("mode 0 or 1 or 2"); break; case 3: System.out.println("mode 2"); break; default: System.out.println("mode default"); break; } |
Если mode равно 0, то код выше выведет в консоль:
1 2 |
mode 0 mode 0 or 1 or 2 |
Если mode равно 1, то код выше выведет в консоль:
1 |
mode 0 or 1 or 2 |
Если mode равно 2, то код выше выведет в консоль:
1 |
mode 0 or 1 or 2 |
Блок default не обязательно указывать в конце блока switch. Он может стоять и в начале, и в середине (но рекомендуется всегда писать его последним, так получается гораздо нагляднее, потому что он выполняется в том случае, если ни один из case -ов не подошёл):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
switch (mode) { case 0: System.out.println("mode 0"); break; default: System.out.println("mode default"); break; case 1: System.out.println("mode 1"); break; case 2: System.out.println("mode 2"); break; } |
Можно даже вообще не указывать блок default:
1 2 3 4 5 6 7 8 9 10 11 |
switch (mode) { case 0: System.out.println("mode 0"); break; case 1: System.out.println("mode 1"); break; case 2: System.out.println("mode 2"); break; } |
Оператор while
Оператор while позволяет выполнить инструкцию или блок инструкций несколько раз.
Его синтаксис:
1 2 |
while (<условие>) <оператор1>; |
И с блоком операторов/инструкций (согласно соглашению о кодировании Java рекомендуется использовать вариант с блоком даже в случае одной инструкции):
1 2 3 4 5 6 |
while (<условие>) { <оператор1>; <оператор2>; ... <оператор3>; } |
Оператор while вычисляет выражение <условие> и выполняет оператор или блок операторов, если результат выражения <условие> равен true. Затем он ещё раз вычисляет и проверяет <условие> и, если оно вернуло true, то снова выполняет оператор или блок операторов. Так выполняется до тех пор, пока <условие> не вернёт false.
Следующий код выведет числа от 0 до 10:
1 2 3 4 5 |
int n = 0; while (n <= 10) { System.out.println(n); n++; } |
Выражение <условие> в while может быть любым, но оно обязательно должно возвращать тип boolean. Следующий код тоже корректен:
1 2 3 4 5 6 7 8 9 10 11 12 |
// Бесконечный цикл while (true) { // операторы } // Это тоже корректный код, но obj1 должен // иметь метод someMethodReturnsBoolean(), // возвращающий boolean. boolean b; while (b = obj1.someMethodReturnsBoolean()) { // операторы } |
Оператор do-while
Оператор do-while похож на оператор while, но он сначала выполняет операторы, а лишь потом проверяет условие, таким образом оператор или блок операторов выполнятся хотя бы один раз.
Примеры:
1 2 3 4 5 6 |
// вывод чисел от 0 до 10 int x = 0; do { System.out.println(x); x++; } while (x <= 10); |
1 2 3 4 5 6 7 8 9 10 |
// Условие ложно изначально, // но выведется 0, так как // сначала будет выполняться // блок операторов, а лишь затем // проверяться условие x = 0; do { System.out.println(x); x++; } while (x < 0); |
Оператор for
Оператор for представляет собой компактную форму итерации по диапазону чисел. Его синтаксис:
1 2 |
for (<инициализация>; <условие>; <инкремент>) <оператор1>; |
Или для блока операторов (согласно соглашению о кодировании в Java рекомендуется использовать этот вариант даже для случая одного оператора):
1 2 3 4 5 6 |
for (<инициализация>; <условие>; <инкремент>) { <оператор1>; <оператор2>; ... <операторN>; } |
Выражение <инициализация> выполняется только один раз перед началом итерации. Переменные, объявленные в <инициализация> действуют только внутри цикла for , включая <инициализация> , <условие> и <инкремент>.
Выражение <условие> выполняется перед каждым циклом итерации. Блок операторов или одиночный оператор выполняются только тогда, когда <условие> вернуло true . Если <условие> возвращает false , то выполнение цикла for завершается.
Выражение <инкремент> выполняется после каждого цикла перед проверкой выражения <условие> . Его обычно используют для увеличения или уменьшения значения.
Любое из выражений <инициализация> , <условие> , <инкремент> можно опустить. Можно даже вообще сделать цикл for без инициализации, условия, инкремента и оператора/блока операторов:
1 2 |
// Бесконечный цикл for (;;); |
Пример использования цикла for для вывода значений от 0 до 10:
1 2 3 |
for (int n = 0; n <= 10; n++) { System.out.println(n); } |
В <инициализация> и в <инкремент> можно указывать несколько выражений инициализации и несколько инкрементов. В этом случае они указываются через запятую и вычисляются слева направо:
1 2 3 |
for (int n = 0, m = 3; n <= 10; n++, m--) { System.out.println("n=" + n + "; m=" + m); } |
Существует ещё специальная форма for для обхода по массивам и коллекциям:
1 2 3 4 |
int[] myarray = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; for (int n : myarray) { System.out.println(n); } |
Выведет в консоль следующее:
1 2 3 4 5 6 7 8 9 10 11 |
0 1 2 3 4 5 6 7 8 9 10 |
Оператор break
Оператор break позволяет прервать текущее выполнение switch или цикла for , while и do-while и перейти к следующему оператору после него. Примеры:
1 2 3 4 5 6 |
int n = 0; while (true) { System.out.println(n); if (n == 10) break; n++; } |
1 2 3 4 5 6 |
int n = 0; do { System.out.println(n); if (n == 10) break; n++; } while (true); |
1 2 3 4 5 |
for (int n = 0; ;) { System.out.println(n); if (n == 10) break; n++; } |
Все приведённые выше примеры выводят в консоль числа от 0 до 10.
В случае вложенных циклов оператор break прерывает выполнение самого глубокого из текущих циклов. Можно прервать внешний цикл, если указать для него метку:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// метка для внешнего цикла. outer_for: for (int n = 0; n < 10; n++) { //... // метка для внутреннего цикла inner_for: for (int m = 0; m < 10; m++) { // прерываем внешний цикл для n == 2 и m ==4 if ((n == 9) && (m == 4)) break outer_for; // прерываем внутренний цикл для n == 7 и m == 2 if ((n == 7) && (m == 2)) break; // можно прервать внутренний цикл и по метке. if ((n == 9) && (m % 2 == 1)) break inner_for; System.out.println("n=" + n + "; m=" + m); } } |
Оператор continue
Оператор continue позволяет пропустить текущую итерацию и перейти сразу к следующей итерации цикла for , while или do-while. Он тоже бывает с меткой и без метки.
Пример без метки:
1 2 3 4 |
for (int n = 0; n <= 10; n++) { if (n % 2 == 0) continue; System.out.println(n); } |
Выведет в консоль:
1 2 3 4 5 |
1 3 5 7 9 |
Пример с меткой:
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// ... outer_label: for (int n = 4; n <= 9; n++) { int m = 3; while (m <= 5) { // Если остаток от деления n на m равен 0, // то переходим к следующей итерации // цикла outer_label if (n % m == 0) continue outer_label; System.out.println("n=" + n + "; m=" + m); m++; } } |
Это выведет в консоль:
1 2 3 4 5 6 7 |
n=4; m=3 n=5; m=3 n=5; m=4 n=7; m=3 n=7; m=4 n=7; m=5 n=8; m=3 |
Оператор return
Оператор return возвращает управление из текущего метода в метод, который вызвал текущий метод. Он имеет две формы: с возвращаемым значением и без.
С возвращаемым значением:
1 |
return <выражение>; |
Пример:
1 |
return m + 3; |
И без возвращаемого значения (для метода с void ):
1 |
return; |
Цикл статей «Учебник Java 8».
Следующая статья — «Пакеты в Java 8».
Предыдущая статья — «Java 8 выражения, инструкции и блоки».
Прекрасные текст, быть может, банальный, но с которым хочется свериться.
Иму замечания по стилистике
Однако согласно соглашению о кодировании в Java использовать подобную возможность не стоит. -> Не следует
(Также запятые)
http://new.gramota.ru/spravka/punctum?layout=item&id=58_693)
на следующую инструкцию за блоком switch -> на следующую за блоком switch инструкцию
если оно вернуло true, то снова выполняет оператор -> если оно вернуло true, снова выполняет оператор
Так выполняется до тех пор, пока не вернёт false. -> Выполнение происходит до тех пор