Операторы сравнения и логические операторы. Условный оператор

Знаешь, что общего у светофора, банкомата и твоего любимого мобильного приложения? Все они постоянно принимают решения. "Если карта действительна — выдай деньги", "если здоровье персонажа на нуле — конец игры", "если пользователь ввел правильный пароль — пусти его в систему". Вот честно, первые пару недель обучения программированию я писал код, который просто выполнялся строчка за строчкой. Сверху вниз. И все. Скучно до невозможности! А потом узнал про условные операторы — и мир программирования сразу стал другим. Программа вдруг начала что-то решать сама! Без условий ты максимум сделаешь калькулятор. Ну или программу "Hello World" в десяти вариациях. А вот игры, мессенджеры, любые сервисы — там без if никуда. Давай разберемся, как это работает в Java.

Логические операторы: штука без которой условия не построишь

Окей, сначала нужно понять базу. Прежде чем писать условия, тебе понадобятся логические операторы. Это такие инструменты, которые позволяют комбинировать проверки. Звучит сложно? Сейчас объясню.

Три кита: И, ИЛИ, НЕ

В Java есть три основных логических оператора. Запомнить легко, потому что логика у них простая: Оператор ! (восклицательный знак) — это "НЕ". Переворачивает все с ног на голову. Было true — стало false. И наоборот. Допустим, у тебя переменная isRaining (идет дождь). Пишешь !isRaining — и получаешь "НЕ идет дождь". Элементарно. Оператор && (два амперсанда) — это логическое "И". Работает строго: оба условия должны быть истинными, иначе результат false. Представь охранника в клубе, которому нужно предъявить И билет, И паспорт с возрастом 18+. Не хватает одного из документов? Извини, братан, проходи мимо. Оператор || (две вертикальные черты) — логическое "ИЛИ". Тут попроще: хватит одного истинного условия. Как акция в магазине: "скидка действует, если у вас карта лояльности ИЛИ день рождения в этом месяце". Достаточно чего-то одного. Смотри пример:

boolean hasTicket = true;
boolean isAdult = false;

// Отрицание
boolean isChild = !isAdult; // true, потому что не взрослый

// Логическое И — нужны ОБА условия
boolean canEnterClub = hasTicket && isAdult; // false (билет есть, но возраст не тот)

// Логическое ИЛИ — хватит одного  
boolean canGetDiscount = isChild || hasTicket; // true

System.out.println("Пустят в клуб: " + canEnterClub); // false
System.out.println("Скидка положена: " + canGetDiscount); // true

Вот и вся магия.

Приоритет операторов (да, и тут своя очередность)

Ладно, допустим, ты напишешь что-то вроде a || b && !c. Что выполнится первым? Компьютер же не экстрасенс, чтобы угадывать твои мысли. Поэтому в Java есть четкие правила: Первым делом работает отрицание !. Потом идет && (логическое И). И только в конце || (логическое ИЛИ). Запомнить можно по аналогии с математикой — там же сначала умножение и деление, а потом сложение и вычитание. Тут похожий принцип. Не уверен в порядке? Ставь скобки. Серьезно, это спасает от множества багов. Скобки всегда в приоритете:

boolean a = true;
boolean b = false;
boolean c = true;

// Без скобок: ! выполнится первым, потом &&, потом ||
boolean result1 = a || b && !c; // получится true

// Со скобками меняем всю логику
boolean result2 = (a || b) && !c; // получится false

System.out.println("Без скобок: " + result1);    // true
System.out.println("Со скобками: " + result2);   // false

Видишь разницу? Одни скобки — и результат другой.

Фишка с ленивыми вычислениями (короткое замыкание)

А вот теперь интересное. Java достаточно умная, чтобы иногда… схалтуривать. В хорошем смысле! Смотри: если у тебя условие с оператором &&, и первая часть уже false — зачем проверять вторую? Результат и так будет false. Java так и делает — пропускает вторую проверку. Это называется "коротким замыканием" или short-circuit evaluation. То же самое с || — если первое условие true, второе даже не смотрит. Пример из жизни:

int balance = 100;
int amount = 500;

// Java проверит balance > 0, увидит true
// и дальше даже не пойдет! Деления на ноль не будет
if (balance > 0 || amount / 0 > 100) {
    System.out.println("Этот код спокойно выполнится");
}

// А вот тут будет беда — первое условие false,
// и Java полезет проверять второе... привет, деление на ноль!
if (balance < 0 && amount / 0 > 100) {
    System.out.println("До сюда не дойдет — будет ошибка");
}

Кстати, есть еще & и | (без удвоения) — они всегда проверяют оба условия. Но в реальных проектах их почти никто не использует для логики. Зачем делать лишнюю работу, если можно не делать?

Операторы сравнения: больше, меньше и все такое

Теперь про операторы сравнения. Тут все проще — обычная школьная математика, только в коде. У нас есть шесть штук: > — больше >= — больше или равно < — меньше <= — меньше или равно == — равно (внимание: два знака равенства!) != — не равно Все они берут два значения (чаще всего числа), сравнивают их и возвращают boolean — либо true, либо false.

int playerHealth = 75;
int maxHealth = 100;
int dangerZone = 30;

boolean isFullHealth = playerHealth == maxHealth;     // false
boolean isDangerous = playerHealth < dangerZone;      // false  
boolean needsHealing = playerHealth <= 50;            // false
boolean isAlive = playerHealth > 0;                   // true
boolean isDamaged = playerHealth != maxHealth;        // true

System.out.println("Здоровье полное: " + isFullHealth);  // false
System.out.println("Нужно лечиться: " + needsHealing);   // false
System.out.println("Персонаж ранен: " + isDamaged);      // true

Частая ошибка новичков: путать == (сравнение) с = (присваивание). Я сам в первые недели постоянно на этом спотыкался!

int score = 100;           // Присваивание: записали 100 в переменную
boolean isWin = score == 100;  // Сравнение: проверяем, равен ли score 100

Один знак равенства — присваивание. Два знака — сравнение. Запомни раз и навсегда.

Приоритет: что считается первым

Когда в одном выражении куча разных операторов, Java выполняет их в определенном порядке. Сначала арифметика (плюсы-минусы), потом сравнения, потом логические операции, и только в конце — присваивание.

int a = 5;
int b = 3;

// Порядок: 5 + 3 = 8, потом 8 > 7, потом результат в переменную
boolean result = a + b > 7; // true

System.out.println(result); // true

В общем-то, интуитивно понятно. Но если сомневаешься — всегда можно скобками явно указать порядок.

Условный оператор if: наконец-то учим программу думать

Окей, теперь самое главное — оператор if. Это основа основ. С его помощью программа начинает вести себя по-разному в зависимости от ситуации.

Простейшая форма if

Синтаксис элементарный:

if (условие) {
    // этот код выполнится, если условие true
}

Условие в скобках возвращает boolean. Если true — код внутри фигурных скобок выполнится. Если false — Java просто пропустит этот блок и пойдет дальше. Живой пример:

int age = 20;

if (age >= 18) {
    System.out.println("Добро пожаловать!");
}

// Если возраст меньше 18, программа просто ничего не выведет

Технически фигурные скобки можно не ставить, если внутри всего одна команда:

int money = 1000;

if (money > 0) 
    System.out.println("Есть деньги на счету");

Но знаешь что? Не делай так. Потом захочешь добавить еще одну строчку кода, забудешь про скобки — и получишь баг, который будет искать полдня. Лучше всегда пиши фигурные скобки. Поверь, так спокойнее.

if-else: или то, или другое

Часто нужно сделать что-то одно, если условие выполнено, и что-то другое — если нет. Для этого придумали else:

if (условие) {
    // сюда, если true
} else {
    // сюда, если false
}

Классика — проверка перед делением на ноль:

int dividend = 100;
int divisor = 0;

if (divisor != 0) {
    int result = dividend / divisor;
    System.out.println("Результат: " + result);
} else {
    System.out.println("На ноль делить нельзя!");
}

Или проверяем четность числа:

int number = 7;

if (number % 2 == 0) {
    System.out.println(number + " — четное");
} else {
    System.out.println(number + " — нечетное");
}
// Выведет: 7 — нечетное

Просто и понятно.

else if: когда вариантов больше двух

Жизнь редко бывает черно-белой. Обычно есть куча вариантов. Вот для этого придумали else if — можно проверить несколько условий подряд:

if (условие1) {
    // если условие1 истинно
} else if (условие2) {
    // если условие1 ложно, а условие2 истинно
} else if (условие3) {
    // если первые два ложны, а условие3 истинно
} else {
    // если вообще ничего не подошло
}

Java идет сверху вниз и останавливается на первом истинном условии. Остальные даже не проверяет. Реальный пример — система оценок:

int score = 85;

if (score >= 90) {
    System.out.println("Оценка: A (Отлично!)");
} else if (score >= 80) {
    System.out.println("Оценка: B (Хорошо)");
} else if (score >= 70) {
    System.out.println("Оценка: C (Удовлетворительно)");
} else if (score >= 60) {
    System.out.println("Оценка: D (Слабовато)");
} else {
    System.out.println("Оценка: F (Эх...)");
}
// Выведет: Оценка: B (Хорошо)

Или игровая механика:

int level = 15;
String difficulty;

if (level < 5) {
    difficulty = "Новичок";
} else if (level < 10) {
    difficulty = "Любитель";
} else if (level < 20) {
    difficulty = "Профи";
} else {
    difficulty = "Бог войны";
}

System.out.println("Сложность: " + difficulty);
// Выведет: Сложность: Профи

Удобно же?

Вложенные if: когда надо проверить что-то внутри проверки

Иногда нужна проверка внутри проверки. Типа, сначала проверяем возраст, а потом — есть ли права:

int age = 25;
boolean hasLicense = true;

if (age >= 18) {
    if (hasLicense) {
        System.out.println("Можете арендовать авто");
    } else {
        System.out.println("Сначала получите права");
    }
} else {
    System.out.println("Слишком молоды");
}

Работает, но злоупотреблять не стоит. Если вложенность больше 2-3 уровней — код превращается в кашу. Лучше объединить условия через &&:

// Плохо: куча вложенных if
if (isOnline) {
    if (hasPermission) {
        if (dataValid) {
            if (networkOk) {
                // делаем что-то
            }
        }
    }
}

// Хорошо: объединили все в одно условие
if (isOnline && hasPermission && dataValid && networkOk) {
    // делаем что-то
}

Второй вариант читается проще. Всегда думай о том, кто будет читать твой код потом (спойлер: это, скорее всего, будешь ты же через три месяца).

Тернарный оператор: if в одну строчку

Есть еще один способ писать условия — тернарный оператор ? :. Это как сокращенный if-else, только возвращает значение:

переменная = условие ? значениеЕслиTrue : значениеЕслиFalse;

Пример:

int age = 20;
String status = age >= 18 ? "Взрослый" : "Ребенок";
System.out.println(status); // Взрослый

Это абсолютно то же самое, что:

int age = 20;
String status;
if (age >= 18) {
    status = "Взрослый";
} else {
    status = "Ребенок";
}
System.out.println(status); // Взрослый

Только короче. Удобно для простых случаев:

int a = 10;
int b = 20;
int max = a > b ? a : b; // max = 20

int price = 1000;
int discount = price > 500 ? 100 : 50; // скидка 100

Но не увлекайся! Если логика сложная — лучше обычный if. Никому не нравится разбираться в тернарниках типа:

// Ужас, не делай так
String result = a > b ? (c > d ? "вариант1" : "вариант2") : (e > f ? "вариант3" : "вариант4");

Такое даже читать больно. Используй тернарник только для простых выборов из двух значений.

Ошибки, на которых все спотыкаются (и ты тоже споткнешься)

Знаешь, есть ошибки, которые делают абсолютно все новички. Я сам на них наступал раз сто. Давай разберем самые популярные, чтобы ты хотя бы знал, что искать, когда что-то не работает. 1. Перепутал = и == Классика жанра. Одинарный знак равенства — это присваивание. Двойной — сравнение.

int x = 5;

// Так НЕ работает! Это попытка присвоить, а не сравнить
if (x = 10) { // Ошибка компиляции
    System.out.println("x равен 10");
}

// А вот так правильно
if (x == 10) {
    System.out.println("x равен 10");
}

Я первую неделю путал постоянно. Потом выработался рефлекс. 2. Сравнивал строки через == Это вообще коварная штука. Иногда работает, иногда нет. Для строк нужен метод .equals():

String name1 = "Максим";
String name2 = "Максим";

// Плохо! Может сработать, а может и нет
if (name1 == name2) { 
    // Тут логика сломается рано или поздно
}

// Правильно
if (name1.equals(name2)) {
    System.out.println("Имена одинаковые");
}

Запомни: для строк всегда .equals(). Для чисел и boolean можно ==. 3. Забыл фигурные скобки Пропустил скобки, думая что в условии одна строка. А там оказалось две. Результат — баг.

int score = 80;

// Опасно! Вторая строка НЕ в условии
if (score > 50)
    System.out.println("Тест пройден");
    System.out.println("Поздравляем!"); // Выполнится ВСЕГДА!

// Правильно
if (score > 50) {
    System.out.println("Тест пройден");
    System.out.println("Поздравляем!");
}

Совет: всегда ставь фигурные скобки. Всегда. Даже если там одна строка. 4. Проверял boolean через == true Лишние проверки. Переменная и так boolean, зачем ее с true сравнивать?

boolean isActive = true;

// Неправильно (хотя работает, но странно выглядит)
if (isActive == true) {
    System.out.println("Активно");
}

// Правильно
if (isActive) {
    System.out.println("Активно");
}

// Для false тоже просто
if (!isActive) {
    System.out.println("Неактивно");
}

5. Пытался использовать число как boolean В некоторых языках можно писать if (1), и это означает true. В Java так нельзя.

int value = 1;

// Ошибка компиляции! Число ≠ boolean
if (value) { 
    System.out.println("Что-то");
}

// Правильно — явно сравниваем
if (value != 0) {
    System.out.println("Число не ноль");
}

Вот такие основные косяки. Если споткнулся на чем-то из этого — не переживай, через это проходят все.

Частые вопросы

В чем разница между & и &&? & и | — это побитовые операторы. Они всегда проверяют оба условия, даже если результат уже понятен. && и || — логические с коротким замыканием, умные, пропускают ненужные проверки. В реальной жизни почти всегда нужны && и ||. Можно объединять условия в одном if? Конечно! Через && и ||:

if (age >= 18 && hasPassport && !isBanned) {
    System.out.println("Заходи");
}

Когда использовать if, а когда switch? if — универсальный, подходит для любых проверок. switch удобнее, когда сравниваешь одну переменную с несколькими конкретными значениями. Но это тема для отдельной статьи. Что делать, если if-ов слишком много? Подумай о рефакторинге. Можно вынести часть логики в отдельный метод, использовать switch, карты (Map), или паттерны проектирования. Длинная цепочка из 10+ else if — это признак, что код пора улучшить. Можно в условии вызывать методы? Да, любое выражение, которое возвращает boolean:

if (text.isEmpty()) {
    System.out.println("Введите текст");
}

if (Math.random() > 0.5) {
    System.out.println("Повезло!");
}

В каком порядке проверяются условия в else if? Строго сверху вниз. Как только Java находит первое истинное условие — останавливается и выполняет соответствующий блок. Все остальные блоки (включая else) пропускаются.