Условные операторы if и switch

Возможность проверять условия – это, наверное, главное, что отличает компьютер от простого калькулятора! Что такое условие и как это работает? Давайте рассмотрим простую математическую задачу. Предположим, пользователь вводит с клавиатуры целочисленное число и нужно вычислить модуль этого числа. Алгоритм программы можно представить в таком виде:

Обратите внимание, что вот здесь в ромбе происходит ветвление работы алгоритма: если x<0, то выполняется умножение на -1, иначе просто выводим введенное число на экран. Это ветвление и есть простейший пример проверки условия. И сейчас мы с вами посмотрим как эту программу можно записать на Java.

Scanner in = new Scanner(System.in);
int x = in.nextInt();
if(x < 0) x = x*-1;
System.out.println(x);
in.close();

Здесь мы сначала задаем целочисленную переменную x, вводим в нее числовое значение с клавиатуры, а вот здесь как раз и реализуется проверка с помощью оператора if. Если условие оказывается истинным, то есть, x действительно меньше 0, то делаем умножение на -1. А если условие ложно, то есть, x>=0, то это умножение делаться не будет. После этого, результат выводится на экран и функция main завершает свою работу.

Чтобы правильно использовать условный оператор if, запомните его синтаксис:

if (<условие>) оператор;

а в качестве условия можно использовать такие выражения:

Давайте рассмотрим такой пример:

float x;
Scanner in = new Scanner(System.in);
System.out.print("Введите число: "); x = in.nextFloat();
 
if (x < 0)  System.out.println("Введенное число "+x+" является отрицательным.");
if (x >= 0) System.out.println("Введенное число "+x+" является неотрицательным.");
 
in.close();

Обратите внимание, эти два условия являются взаимоисключающими. То есть, если истинно первое, то второе точно ложно, и наоборот. Значит, вместо двух проверок можно использовать одну, но записанную в таком виде:

if (x < 0)  System.out.println("Введенное число "+x+" является отрицательным.");
else System.out.println("Введенное число "+x+" является неотрицательным.");

Здесь оператор else можно перевести как «иначе», то есть, оператор, стоящий после else будет выполнен только в том случае, если первое условие окажется ложным. Такая конструкция условного оператора if более логична да и к тому же будет быстрее работать. Синтаксис этой конструкции следующий:

if (<условие>)
оператор1;
else
оператор2;

Давайте теперь преобразуем нашу программу таким образом:

float x;
Scanner in = new Scanner(System.in);
System.out.print("Введите число: "); x = in.nextFloat();
 
if (x < 0)  System.out.println("Введенное число "+x+" является отрицательным.");
else if (x > 0)  System.out.println("Введенное число "+x+" является положительным.");
else System.out.println("Введенное число равно 0.");
 
in.close();

Смотрите, здесь используется конструкция if .. else два раза подряд, причем, первый else относится к первому if, а второй else – ко второму if. В результате, сначала проверяется первое условие, если оно ложно, то переходим ко второму условию, если и оно ложно, то получается, что x=0, так как все три условия взаимоисключающие. По этому принципу можно написать сколько угодно таких if .. else, идущих друг за другом.

Во всех рассмотренных примерах после условного оператора шел только один оператор – это был вызов метода println или оператор if. Но что если мы хотим выполнить несколько операторов по некоторому условию? Для этого все эти операторы нужно заключить в фигурные скобки:

if (<условие>)
{
список операторов
}
else
{
список операторов
}

Как пример рассмотрим такую программу. Пользователь выбирает площадь какой фигуры он хочет вычислить:

short item = -1;
Scanner in = new Scanner(System.in);
System.out.print("1 - площадь треугольника\n2 - площадь прямоугольника\n");
item = in.nextShort();
 
double h, a, S = 0;
if (item == 1) {
    System.out.print("Введите высоту и основание треугольника: ");
    h = in.nextDouble();
    a = in.nextDouble();
    S = 0.5*h*a;
}
else if (item == 2) {
    System.out.print("Введите стороны прямоугольника: ");
    h = in.nextDouble();
    a = in.nextDouble();
    S = h * a;
}
 
System.out.println("Площадь равна: " + S);
 
in.close();

И здесь по условию выполняется сразу несколько операторов, поэтому они заключены в фигурные скобки. Запустим и посмотри работу этой программы.

Если все это понятно, то дальше сделаем следующий шаг и рассмотрим такую задачу. Предположим пользователь с клавиатуры вводит некоторое число a и мы хотим определить попадает ли это число в диапазон ? Конечно, это можно сделать так:

double a;
Scanner in = new Scanner(System.in);
a = in.nextDouble();
 
if (a >= -2)
    if (a <= 5)
        System.out.println("a принадлежит [-2; 5]");
 
in.close();

То есть, когда выполняются оба условия: и a>=-2 и a <=5, то мы увидим на экране сообщение. Но было бы удобнее записать эти условия в виде одного составного. И в Java это делается так:

if (a >= -2 && a <= 5) System.out.println("a принадлежит [-2; 5]");

Обратите внимание вот на эти два амперсанда. В условных операторах они означают И. То есть, данное условие считается истинным, когда истинно и первое и второе выражение. Если хотя бы одно из них будет ложным, то ложно будет и все выражение. Вот так работает И в составных условиях.

А теперь реализуем противоположную задачу, когда нужно определить, что , получим такое условие:

if (a < -2 || a > 5) System.out.println("a не принадлежит [-2; 5]");

Здесь две вертикальные черты означают ИЛИ (этот символ набирается путем нажатия shift+\ в латинской раскладке клавиатуры). Такое составное условное выражение считается истинным, если истинно или первое, или второе условие. В данном случае, если a или меньше -2, или больше 5, то число не принадлежит диапазону [-2; 5].

И последняя условная логическая операция НЕ, которая записывается как !. Например, если мы перепишем последнее условие так:

if (!(a < -2 || a > 5)) System.out.println("a принадлежит [-2; 5]");

то получим первое условие if(a >= -2 && a<=5), то есть, попадание переменной a в диапазон [-2; 5]. В Java эту операцию можно применить к отдельной булевой переменной вот так:

boolean fl = true;
if (fl)  System.out.println("fl = true");
if (!fl)  System.out.println("fl = false");

Подобно операциям умножения и сложения в математике, логические операции И ИЛИ НЕ, также имеют свои приоритеты. Самый высокий приоритет имеет операция НЕ, т.е. такая операция выполняется в первую очередь. Более низкий приоритет у операции И, и наконец самый маленький приоритет у операции ИЛИ. Данные приоритеты необходимо учитывать, при составлении сложных условий. Например, мы хотим определить, что переменная x не попадает в диапазон [0; 2], а переменная y попадает в [5; 7]. Это можно реализовать с помощью такого составного условия:

int x = -1, y = 5;
if ((x < 0 || x > 2) && y >= 5 && y <= 7)
    System.out.println("x не принадлежит [0; 2], y принадлежит [5; 7]");

Обратите внимание, что здесь необходимо использовать круглые скобки, чтобы вот эти два условия проверялись по ИЛИ. А вот если убрать эти скобки, то получим условие проверки когда x<0 или когда x>2 И y>=5 И y<=7. То есть, оно будет истинно при любых x<0 или когда x>2, а y попадает в [5;7]. Как видите это уже другое условие.

Оператор switch

В Java есть еще один условный оператор switch. Он используется когда из множества вариантов нужно выбрать один, соответствующий значению проверяемой переменной. Очень часто этот оператор используется в выборе пунктов меню пользовательского интерфейса. И мы такой пример и рассмотрим.

short item;
System.out.print("0 - выход из программы\n1 - площадь треугольника\n2 - площадь прямоугольника\n3 - площадь круга\n4 - площадь трапеции\n");
Scanner in = new Scanner(System.in);
item = in.nextShort();
 
switch (item) {
    case 1: System.out.println("выбрана площадь треугольника");
    case 2: System.out.println("выбрана площадь прямоугольника");
    case 3: System.out.println("выбрана площадь круга");
    case 4: System.out.println("выбрана площадь трапеции");
    default: System.out.println("не выбран ни один из пунктов меню");
}
 
in.close();

Здесь вначале отображается меню, затем пользователь вводит номер пункта меню и далее идет условный оператор switch, который проверяет переменную item на равенство значений. Причем, обратите внимание как он работает. Предположим, вводим значение 3, то есть, item=3, тогда оператор switch нас сразу переместит на строчку case 3, минуя предыдущие строки. Как вы понимаете, это работает быстрее оператора if, так как if проверял бы каждую строчку. А вот что дальше. После того, как мы перешли на 3, далее будут выполняться все последующие операторы, написанные в switch, то есть, case 4 и default. Таким образом, получаем, в начале сразу переходим к нужному выбору, а затем, перебираем все до конца. Это бывает не всегда удобно, и после выбора нужного пункта хотелось бы завершить все проверки. Для этого используется оператор break, который досрочно завершает работу оператора switch и в нашем примере его можно записать так:

switch (item) {
    case 1: System.out.println("выбрана площадь треугольника");break;
    case 2: System.out.println("выбрана площадь прямоугольника");break;
    case 3: System.out.println("выбрана площадь круга");break;
    case 4: System.out.println("выбрана площадь трапеции");break;
    default: System.out.println("не выбран ни один из пунктов меню");
}

Теперь, когда мы нашли нужный пункт, выполнили его, оператор break завершает все проверки и мы переходим к in.close().

И последнее. В операторе switch строчка с default выполняется в том случае, если не сработало ни одно из условий. Причем, default можно и не использовать, если в нем нет необходимости, т.е. например, программу можно записать и так:

switch (item) {
    case 1: System.out.println("выбрана площадь треугольника");break;
    case 2: System.out.println("выбрана площадь прямоугольника");break;
    case 3: System.out.println("выбрана площадь круга");break;
    case 4: System.out.println("выбрана площадь трапеции");break;
}

Вот мы с вами рассмотрели два условных оператора if и switch и вы теперь знаете как они работают в Java.

Условные операторы if и switch

Оператор switch

Видео по теме