Ветвление
Давайте теперь узнаем, что такое оператор ветвления, для чего он нужен и как записывается.
Опера́тор ветвле́ния (усло́вная инстру́кция, усло́вный опера́тор) — оператор, конструкция языка программирования, обеспечивающая выполнение определённой команды (набора команд) только при условии истинности некоторого логического выражения, либо выполнение одной из нескольких команд (наборов команд) в зависимости от значения некоторого выражения.
Звучит сложно, но на деле всё просто. Разберём пример из жизни. Давайте подумаем, как мы решаем, стоит ли брать с собой зонт, когда выходим на улицу. Отвечать, конечно, можно по-разному, но самый простой и очевидный ответ:
Если на улице идёт дождь, то берём зонт.
То есть при выполнении какого-либо условия в конкретной ситуации мы можем вести себя по-разному. Точно так же и программа в зависимости от условия может выполнять различные действия.
В общем виде оператор ветвления с одной ветвью записывается так:
if (<условие>) {
команда 1;
команда 2;
...
}
Давайте рассмотрим элементарный блок кода, в котором используется ветвление:
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
if (a > 0) {
System.out.println("Ваше число положительное");
}
При выполнении этого кода, если мы введём положительное число, то на экране появится надпись "Ваше число положительное". В противном же случае ничего не появится.
Но это была лишь укороченная запись оператора. Его полная запись аналогична примеру:
Если на улице идёт дождь, то берём зонт, иначе возьмём солнцезащитные очки.
А общий вид записывается так:
if (<условие>) {
команда 1;
команда 2;
...
}else{
команда 1;
команда 2;
...
}
Теперь давайте дополним наш код :
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
if (a > 0) {
System.out.println("Ваше число положительное");
}else{
System.out.println("Ваше число отрицательное");
}
Теперь, если мы введём не положительное число, то будет выведена фраза: "Ваше число отрицательное".
Но программа пока работает неверно, так как 0 не является ни положительным, ни отрицательным числом. Что тогда делать? Улучшим нашу программу, прописав новую ветку развития событий. Это можно сделать двумя способами, давайте разберём каждый из них.
Первый:
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
if (a > 0) {
System.out.println("Ваше число положительное");
}
if (a < 0) {
System.out.println("Ваше число отрицательное");
}else{
System.out.println("Ваше число - 0");
}
Второй:
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
if (a > 0) {
System.out.println("Ваше число положительное");
}else{
if (a < 0) {
System.out.println("Ваше число отрицательное");
}else{
System.out.println("Ваше число - 0");
}
}
Второй способ является правильным, так как в первом случае всегда будет проверяться 2 условия. В следствии чего на экран может вывестись две строки. Попробуйте скомпилировать код и ввести сначала отрицательное число, потом 0, потом положительное число. В чём разница? Давайте взглянем на блок - схемы.
Первый вариант:
Второй вариант:
Операторы сравнения
Для записи сравнения используются различные операторы. Вот основные:> - больше
< - меньше
>= - больше или равно
<= - меньше или равно
== - равно
!= - не равно
Так же, для комбинирования условий используются следующие конструкции:&& - логическое "И"
|| - логическое "ИЛИ"
Если вы хотите комбинировать условия, то берите ваши "простые" условия, записывайте их в дополнительные круглые скобочки и соединяйте между собой с помощью && или ||.Например:
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
if ((a == 6) && (b != 3)) {
System.out.println("Ура");
}
Этот код выведет "Ура" только при условии, что первое число равно 6, а второе не равно 3.Немножко про тип данных boolean и сравнение строк
Что же можно записывать в качестве условия? Ответ простой - любое выражение, которое может быть либо истинным, либо ложным. Но это и есть тип данных boolean. Переменная такого типа может принимать значение либо true (истина, 1) либо false (ложь, 0). Поэтому, например, результат такого значения можно занести в переменную.
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
boolean a_is_pozitive = a > 0;
if (a_is_pozitive) {
System.out.println("Ваше число положительное");
}
Есть команды, которые возвращают значение типа boolean.Строки - ссылочный тип данных, поэтому обычное сравнение для него не работает, вместо этого существует команда (правильно называть их, конечно, методы, но пока так) s1.equals(s2). Эта команда вернёт истину, если строки равны, и ложь, если нет. Знак "!" обозначает отрицание чего-либо. Если вы поставите его перед конструкцией, которая возвращает значение boolean, то ! его инвертирует. Пример:
Scanner sc = new Scanner(System.in);
String s1 = sc.nextLine();
String s2 = sc.nextLine();
if (!s1.equals(s2)) {
System.out.println("Строки не совпадают");
}else{
System.out.println("Строки совпадают");
}
Операторы присваивания
Операторы присваивания - это специальные команды, которые позволяют занести значение в переменную. С самым простым из них мы уже познакомились, это знак "=".
int a = 5; // в переменную a заносится значение 5
String b = "Hi"; // в переменную b заносится значение "Hi"
Но есть и более интересные операторы, которые позволяют нам писать код чуть проще. Представим, что нам нужно увеличить значение переменной а на 10. Это можно сделать так:
int a = 20;
a = a + 10;
Однако есть более лаконичная запись второй строки:
int a = 20;
a += 10;
Этот трюк работает со всеми знаками:int a = 5;
a += 10; // a = 15 a *= 2; // a = 30 a /= 3; // a = 10 a -= 2; // a = 8 a %= 3; // a = 2
Помимо этого, особую позицию в программировании занимает увеличение или уменьшение значения переменной на 1. Это называют инкрементирование и декрементирование.Следующие записи позволяют увеличивать значение переменной на 1
int a = 10;
a++; //постинкримент, a = 11
++a; //прединкремент, a = 12
Но если каждая из команд меняет значение переменной, то зачем их 2? Почему просто не оставить одну. Ответ прост. Помимо того, что инкремент увеличивает значение переменной, он также и возвращает значение, которое тоже можно записать в переменную, и вот тут уже есть разница. Постинкримент сначала возвращает значение переменной, а потом увеличивает его, а прединкремент наоборот.
int a = 10;
int b = a++; // b = 10, a = 11
int c = ++a; // c = 12, a = 12
Аналогичные рассуждения справедливы и для декремента. Он работает также, только со знаком минус:int a = 10;
int b = a--; // b = 10, a = 9
int c = --a; // c = 8, a = 8
Свои вопросы можете задать в телеграмм-канале
Курс по Java - разработке бесплатно(2 урок)
Курс по Java - разработке бесплатно(4 урок)