Операторы сравнения и логические операторы — Java

Что это и зачем?

Представь, что ты — робот, который принимает решения. Например: «Если на улице идёт дождь, то взять зонтик». Или: «Если у меня есть 100 рублей И я хочу мороженое, то купить его». В программировании такие решения помогают принимать операторы сравнения (они сравнивают числа или текст) и логические операторы (они соединяют несколько условий в одно).

В Java, как и в жизни, у нас есть вопросы: «Больше ли 10 число 5?», «Равны ли два слова?», «Выполняются ли одновременно два условия?». Ответы всегда «да» (true) или «нет» (false). Это похоже на светофор: если горит зелёный (true) — идём, если красный (false) — стоим.

Зачем это нужно? Без них компьютер не сможет сам решать, что делать в разных ситуациях. Например, в игре: если у игрока закончились жизни (жизни == 0), то показывать «Game Over». Или в калькуляторе: если ввели число больше 100, то выводить предупреждение. Операторы сравнения и логические операторы — это основа любого «умного» поведения программ.

В Python, кстати, всё очень похоже: там тоже есть ==, !=, >, <, >=, <= и логические and, or, not. Но в Java есть одно важное отличие: строки (текст) сравниваются не через ==, а через специальную команду .equals(). Мы это разберём подробно.

Примеры кода с объяснением

Пример 1: Сравнение чисел (простое «больше/меньше»)

// Объявляем переменные с числами
int возрастПети = 12;
int возрастВаси = 14;

// Сравниваем: возраст Пети больше возраста Васи?
boolean петяСтарше = возрастПети > возрастВаси;
System.out.println("Петя старше Васи? " + петяСтарше); // Выведет: false

// Сравниваем: возраст Пети меньше возраста Васи?
boolean петяМладше = возрастПети < возрастВаси;
System.out.println("Петя младше Васи? " + петяМладше); // Выведет: true

// Проверяем на равенство
boolean ониРовесники = возрастПети == возрастВаси;
System.out.println("Они одного возраста? " + ониРовесники); // Выведет: false

// Проверяем на неравенство
boolean разныйВозраст = возрастПети != возрастВаси;
System.out.println("Возраст разный? " + разныйВозраст); // Выведет: true

Объяснение: Мы создали две переменные с числами. Оператор > проверяет, больше ли первое число второго. Если да — значение true, иначе false. Оператор < — наоборот. == проверяет равенство (обрати внимание: два знака равно, а не один! Один знак — это присваивание). != — проверяет, что числа не равны. Результат каждого сравнения — это логическое значение true или false, которое мы сохраняем в переменную типа boolean (логический тип).

Пример 2: Сравнение строк (текста) — важное отличие от Python

String имя1 = "Аня";
String имя2 = "Аня";
String имя3 = "Ваня";

// Сравниваем строки через equals (не через ==!)
boolean аняИАняОдинаковы = имя1.equals(имя2);
System.out.println("Имя1 и Имя2 одинаковы? " + аняИАняОдинаковы); // true

boolean аняИВаняОдинаковы = имя1.equals(имя3);
System.out.println("Имя1 и Имя3 одинаковы? " + аняИВаняОдинаковы); // false

// Сравниваем без учёта регистра (большие/маленькие буквы)
String имя4 = "аня";
boolean безУчетаРегистра = имя1.equalsIgnoreCase(имя4);
System.out.println("Аня и аня (без учёта регистра)? " + безУчетаРегистра); // true

// А вот так делать НЕЛЬЗЯ (почему — объясним в ошибках)
boolean опасноСравнение = (имя1 == имя2);
System.out.println("Через ==: " + опасноСравнение); // Может выдать true, но это случайно!

Объяснение: В Java строки — это не простые числа, а сложные объекты. Оператор == у них проверяет, лежат ли строки в одном и том же месте памяти, а не одинаковый ли у них текст. Поэтому для сравнения текста используют метод .equals(). Если хочешь сравнить без учёта больших/маленьких букв (например, «Аня» и «аня»), используй .equalsIgnoreCase(). В Python, кстати, для строк можно использовать == — там это работает правильно. Но в Java — запомни: строки только через equals!

Пример 3: Логические операторы — «И» (&&), «ИЛИ» (||), «НЕ» (!)

int температура = 25;
boolean солнечно = true;
boolean естьВетер = false;

// Проверяем сложное условие: "Идти гулять, если тепло И солнечно"
boolean можно_гулять = (температура > 20) && солнечно;
System.out.println("Можно гулять? " + можно_гулять); // true (25 > 20 И солнечно = true)

// Проверяем: "Взять куртку, если холодно ИЛИ ветрено"
boolean взятьКуртку = (температура < 15) || естьВетер;
System.out.println("Взять куртку? " + взятьКуртку); // false (НЕ холодно И НЕ ветрено)

// Используем "НЕ": "Если НЕ идет дождь, то идем гулять"
boolean идетДождь = false;
boolean неИдетДождь = !идетДождь; // ! делает false -> true
System.out.println("Дождя нет? " + неИдетДождь); // true

// Сложный пример: "Остаться дома, если холодно И (дождь ИЛИ ветер)"
int температура2 = 10;
boolean дождь = true;
boolean ветер = false;
boolean остатьсяДома = (температура2 < 15) && (дождь || ветер);
System.out.println("Остаться дома? " + остатьсяДома); // true (холодно И дождь)

Объяснение: Логические операторы работают как в математике и в жизни. && (И) даёт true только если оба условия true. || (ИЛИ) даёт true, если хотя бы одно условие true. ! (НЕ) переворачивает значение: true становится false, false — true. В Python то же самое, только пишется словами: and, or, not. В Java используются символы, но смысл абсолютно тот же. Скобки помогают задать порядок: сначала вычисляется то, что в скобках, потом остальное.

Пример 4: Использование в if-else (реальные решения)

int баллы = 85;
int проходнойБалл = 70;

if (баллы >= проходнойБалл) {
    System.out.println("Ты прошёл! Поздравляю!");
} else {
    System.out.println("Попробуй ещё раз.");
}
// Выведет: "Ты прошёл! Поздравляю!"

// Пример с несколькими условиями
int возраст = 16;
boolean сРодителями = true;

if (возраст >= 18 || сРодителями) {
    System.out.println("Можно войти в кинотеатр на фильм 18+");
} else {
    System.out.println("Вход запрещён");
}
// Выведет: "Можно войти в кинотеатр на фильм 18+" (потому что с родителями)

// Пример с вложенными условиями
int время = 14; // 14 часов дня
if (время >= 6 && время < 12) {
    System.out.println("Доброе утро!");
} else if (время >= 12 && время < 18) {
    System.out.println("Добрый день!");
} else if (время >= 18 && время < 23) {
    System.out.println("Добрый вечер!");
} else {
    System.out.println("Спокойной ночи!");
}
// Выведет: "Добрый день!"

Объяснение: Конструкция if проверяет условие в скобках. Если оно true, выполняется код в фигурных скобках. Если false — выполняется код после else (если он есть). Можно использовать else if для нескольких вариантов. Логические операторы помогают создавать сложные условия: например, «возраст >= 18 ИЛИ с родителями». Обрати внимание: в Java для И используется &&, а не одно & (одно & — это побитовая операция, она редко нужна новичкам).

Пример 5: Сравнение символов и булевых значений

// Сравнение символов (char)
char буква1 = 'A';
char буква2 = 'B';
boolean буквыРавны = (буква1 == буква2);
System.out.println("Буквы равны? " + буквыРавны); // false

// Символы можно сравнивать по алфавиту (коду ASCII)
boolean буква1Меньше = (буква1 < буква2); // 'A' (65) < 'B' (66)
System.out.println("A меньше B? " + буква1Меньше); // true

// Булевые значения тоже можно сравнивать, но редко
boolean правда = true;
boolean ложь = false;
boolean равныЛи = (правда == ложь);
System.out.println("true и false равны? " + равныЛи); // false

// Интересный факт: true > false? 
boolean правдаБольше = (правда > ложь); // true считается как 1, false как 0
System.out.println("true > false? " + правдаБольше); // true (потому что 1 > 0)

Объяснение: Символы (char) в Java хранятся как числа (коды из таблицы ASCII). Поэтому их можно сравнивать операторами <, >, ==. 'A' имеет код 65, 'B' — 66, поэтому 'A' < 'B'. Булевы значения (boolean) тоже можно сравнивать: true считается как 1, false как 0. Но на практике булевы значения редко сравнивают между собой — обычно их используют в условиях. В Python символы тоже сравниваются по коду, но там нет отдельного типа char — используется строка из одного символа.

Типичные ошибки

Ошибка 1: Путаница между = и ==

Один знак равно = — это присваивание (положить значение в переменную). Два знака == — это сравнение (проверить, равны ли значения). Ошибка: написать if (возраст = 18) вместо if (возраст == 18). Java на это ругнётся ошибкой компиляции, потому что внутри if должно быть логическое значение (true/false), а присваивание возвращает число. В Python, кстати, такая ошибка тоже возможна, но Python не ругается — он просто присвоит и потом проверит, не ноль ли это. В Java это сразу ошибка, что хорошо — ты сразу узнаешь о проблеме.

Ошибка 2: Сравнение строк через ==

Мы уже говорили: для строк используй .equals(). Если написать if (строка1 == строка2), то Java может выдать true, если строки лежат в одной области памяти (так называемый «пул строк»), но может и false, если они созданы по-разному. Это ненадёжно. Правильно: if (строка1.equals(строка2)). Для сравнения с игнорированием регистра: строка1.equalsIgnoreCase(строка2).

Ошибка 3: Использование & вместо && и | вместо ||

Одиночные & и | — это побитовые операторы (работают с двоичными разрядами чисел). Они тоже могут проверять логические условия, но делают это всегда — проверяют обе части, даже если первая уже дала false. Двойные && и || — это «ленивые» операторы: если первая часть уже даёт false (для &&) или true (для ||), вторую часть они даже не проверяют. Это быстрее и безопаснее. Пример: if (x != 0 && 10 / x > 2) — если x = 0, то вторая часть не будет вычисляться, и мы избежим деления на ноль. Если бы мы написали &, то Java попыталась бы вычислить 10 / 0 и программа бы упала с ошибкой.

Ошибка 4: Забытые скобки в сложных условиях

Если у тебя несколько логических операторов, всегда используй скобки, чтобы задать порядок. Пример: if (a > 0 && b > 0 || c > 0) — без скобок неясно, что имелось в виду: (a > 0 && b > 0) || (c > 0) или a > 0 && (b > 0 || c > 0). В Java у операторов есть приоритет: ! — самый высокий, потом &&, потом ||. Но лучше не полагаться на это, а ставить скобки явно. Это сделает код понятнее и для тебя, и для других.

Ошибка 5: Сравнение чисел с плавающей точкой (double, float) на точное равенство

Из-за погрешностей вычислений числа типа double не всегда точно равны. Например: 0.1 + 0.2 == 0.3 может дать false (на самом деле 0.1 + 0.2 = 0.30000000000000004). Для сравнения таких чисел используют проверку «почти равны»: Math.abs(a - b) < 0.0001. В Python та же проблема. Для целых чисел (int, long) такой проблемы нет — их можно смело сравнивать через ==.

Ошибка 6: Забыть про тип boolean

Иногда новички пишут: if (x = 5) (с одним =) или if (x), надеясь, что Java сама поймёт, что x — это число, и 0 — это false, а не 0 — true. В Java так нельзя! Условие в if должно быть именно boolean (true/false). Нельзя написать if (5) — будет ошибка компиляции. В Python, кстати, можно: if 5: сработает, потому что 5 — это «правдивое» значение. В Java — только true или false.

Ошибка 7: Путаница между & и && в логических выражениях с числами

Если ты пишешь if (x & y) (с одним &), а x и y — числа, то это побитовая операция И, которая даст число, а не boolean. Java потом попытается использовать это число как условие — и выдаст ошибку,