Управляющая логика
Область видимости блоков
Блок состоит из ряда операторов Java, заключенных в фигурные скобки. Блоки определяют область видимости переменных и могут быть вложенными один в другой. Ниже приведен пример одного блока, вложенного в другой блок в методе main().
public static void main(String[] args) {
int n;
{
int k;
} // переменная k определена только в этом блоке
}
В языке Java нельзя объявлять переменные с одинаковым именем в двух вложенных блоках. Например, приведенный ниже фрагмент кода содержит ошибку и не будет скомпилирован.
public static void maiп(String(] args) {
int n;
{
int k;
int n; // ОШИБКА: переопределить переменную n
// во внутреннем блоке нельзя
}
}
Условные операторы
Данные операторы позволяют направить работу программы по одному из путей в зависимости от определенных условий.
if/else
Выражение if/else проверяет истинность некоторого условия и в зависимости от результатов проверки выполняет определенный код:
int num1 = 6;
int num2 = 4;
if (num1 > num2) {
System.out.println("Первое число больше второго");
}
После ключевого слова if ставится условие. И если это условие выполняется, то срабатывает код, который помещен далее в блоке if после фигурных скобок.
Так как, в данном случае первое число больше второго, то выражение num1 > num2 истинно и возвращает значение true. Следовательно, управление переходит в блок кода после фигурных скобок и начинает выполнять содержащиеся там инструкции, а конкретно метод System.out.println("Первое число больше второго");. Если бы первое число оказалось бы меньше второго или равно ему, то инструкции в блоке if не выполнялись бы.
Если необходимо, чтобы при несоблюдении условия также выполнялись какие-либо действия, можно добавить блок else:
int num1 = 6;
int num2 = 4;
if (num1 > num2) {
System.out.println("Первое число больше второго");
} else {
System.out.println("Первое число меньше второго");
}
Но при сравнении чисел мы можем насчитать три состояния: первое число больше второго, первое число меньше второго и числа равны. С помощью выражения else if, можно обрабатывать дополнительные условия:
int num1 = 6;
int num2 = 8;
if (num1 > num2) {
System.out.println("Первое число больше второго");
} else if (num1 < num2) {
System.out.println("Первое число меньше второго");
} else {
System.out.println("Числа равны");
}
Также можно соединить сразу несколько условий, используя логические операторы:
int num1 = 8;
int num2 = 6;
if (num1 > num2 && num1 > 7) {
System.out.println("Первое число больше второго и больше 7");
}
Здесь блок if будет выполняться, если num1 > num2 равно true и одновременно num1 > 7 равно true.
switch
Конструкция switch/case аналогична конструкции if/else, так как позволяет обработать сразу несколько условий:
int num = 8;
switch (num) {
case 1:
System.out.println("число равно 1");
break;
case 8:
System.out.println("число равно 8");
num++;
break;
case 9:
System.out.println("число равно 9");
break;
default:
System.out.println("число не равно 1, 8, 9");
}
После ключевого слова switch в скобках идет сравниваемое выражение. Значение этого выражения последовательно сравнивается со значениями, помещенными после операторов сase. И если совпадение найдено, выполняется соответствующий блок сase.
В конце блока сase ставится оператор break, чтобы избежать выполнения других блоков. Например, если убрать оператор break в следующем случае:
case 8:
System.out.println("число равно 8");
num++;
case 9:
System.out.println("число равно 9");
break;
то выполнился бы блок case 8, (поскольку переменная num равна 8). Но так как в этом блоке оператор break отсутствует, то начал бы выполняться блок case 9.
Если мы хотим также обработать ситуацию, когда совпадения не будет найдено, то можно добавить блок default, как в примере выше. Хотя блок default необязателен.
Также мы можем определить одно действие сразу для нескольких блоков case подряд:
int num = 3;
int output = 0;
switch (num) {
case 1:
output = 3;
break;
case 2:
case 3:
case 4:
output = 6;
break;
case 5:
output = 12;
break;
default:
output = 24;
}
System.out.println(output);
Тернарный оператор
Тернарный оператор имеет следующий синтаксис: [первый операнд - условие] ? [второй операнд] : [третий опер анд]. Таким образом, в этой операции участвуют сразу три операнда. В зависимости от условия тернарный оператор возвращает второй или третий операнд: если условие равно true, то возвращается второй операнд; если условие равно false, то третий. Например:
int x=3;
int y=2;
int z = x < y ? (x + y) : (x - y);
System.out.println(z);
Здесь результатом тернарной операции является переменная z. Сначала проверяется условие x < y. И если оно соблюдается, то z будет равно второму операнду (x+y), иначе z будет равно третьему операнду.
Циклы
Еще одним видом управляющих конструкций являются циклы. Циклы позволяют в зависимости от определенных условий выполнять определенное действие множество раз. В языке Java есть следующие виды циклов:
fordo...whilewhile
for
Цикл for имеет следующее формальное определение:
for ([инициализация счетчика]; [условие]; [изменение счетчика]) {
// действия
}
Рассмотрим стандартный цикл for:
for (int i = 1; i < 9; i++) {
System.out.printf("Квадрат числа %d равен %d \n", i, i * i);
}
Первая часть объявления цикла - int i = 1 создает и инициализирует счетчик i. Счетчик необязательно должен представлять тип int. Это может быть и любой другой числовой тип, например, float. Перед выполнением цикла значение счетчика будет равно 1. В данном случае это то же самое, что и объявление переменной.
Вторая часть - условие, при котором будет выполняться цикл. В данном случае цикл будет выполняться, пока i не достигнет 9.
И третья часть - изменение счетчика на единицу. Опять же нам необязательно увеличивать на единицу. Можно уменьшать: i--.
В итоге блок цикла сработает 8 раз, пока значение i не станет равным 9. И каждый раз это значение будет увеличиваться на 1.
Необязательно указывать все условия при объявлении цикла. Например, можно написать так:
int i = 1;
for (;;) {
System.out.printf("Квадрат числа %d равен %d \n", i, i * i);
}
Определение цикла осталось тем же, только теперь блоки в определении у нас пустые: for (;;). Теперь нет инициализированной переменной-счетчика, нет условия, поэтому цикл будет бесконечным.
Либо можно опустить ряд блоков:
int i = 1;
for (; i < 9;) {
System.out.printf("Квадрат числа %d равен %d \n", i, i * i);
i++;
}
Этот пример эквивалентен первому примеру: у нас также есть счетчик, только создан он вне цикла. У нас есть условие выполнения цикла. И есть изменение счетчика уже в самом блоке for.
Цикл for может определять сразу несколько переменных и управлять ими:
int n = 10;
for (int i = 0, j = n - 1; i < j; i++, j--) {
System.out.println(i * j);
}
do...while
Цикл do сначала выполняет код цикла, а потом проверяет условие в инструкции while. И пока это условие истинно, цикл повторяется. Например:
int j = 7;
do {
System.out.println(j);
j--;
} while (j > 0);
В данном случае код цикла сработает 7 раз, пока j не окажется равным нулю. Важно отметить, что цикл do гарантирует хотя бы однократное выполнение действий, даже если условие в инструкции while не будет истинно. Можно написать:
int j = -1;
do {
System.out.println(j);
j--;
} while (j > 0);
Хотя переменная j изначально меньше 0, цикл все равно один раз выполнится.
while
Цикл while сразу проверяет истинность некоторого условия, и если условие истинно, то код цикла выполняется:
int j = 6;
while (j > 0) {
System.out.println(j);
j--;
}
Операторы прерывания логики управления программой (break и continue)
Оператор break позволяет выйти из цикла в любой его момент, даже если цикл не закончил свою работу:
Например:
for (int i = 0; i < 10; i++) {
if (i == 5)
break;
System.out.println(i);
}
Когда счетчик станет равным 5, сработает оператор break, и цикл завершится.
Теперь сделаем так, чтобы если число равно 5, цикл не завершался, а просто переходил к следующей итерации. Для этого используем оператор continue:
for (int i = 0; i < 10; i++) {
if (i == 5)
continue;
System.out.println(i);
}
В этом случае, когда выполнение цикла дойдет до числа 5, программа просто пропустит это число и перейдет к следующему.