Логический тип boolean — true, false и логические операции

Изучаем тип boolean, операторы сравнения, логические операторы AND, OR, NOT, таблицы истинности и short-circuit вычисления

Зачем нужен логический тип?

В повседневной жизни мы постоянно принимаем решения на основе условий: «если на улице дождь — возьму зонтик», «если я голоден — поем». Компьютеры делают то же самое, но на основе логических значений: true (истина) или false (ложь).

Тип boolean — самый простой тип в Java. Он может хранить только два значения: true или false. Никаких чисел, никаких символов — только «да» или «нет», «истина» или «ложь».

Это как выключатель света: он может быть только включён (true) или выключен (false). Нет промежуточного состояния.

Объявление и присваивание

Объявление переменной boolean идентично другим типам:

public class BooleanBasic {
    public static void main(String[] args) {
        boolean isRaining = true;
        boolean isSunny = false;
        boolean temperatureAboveZero = true;

        System.out.println("Идёт дождь: " + isRaining);
        System.out.println("Солнечно: " + isSunny);
        System.out.println("Температура выше нуля: " + temperatureAboveZero);
    }
}

boolean также поддерживает вывод типа (var) с Java 10:

public class BooleanVar {
    public static void main(String[] args) {
        var flag = true;
        var result = false;

        System.out.println("flag: " + flag);
        System.out.println("result: " + result);
    }
}

Операторы сравнения

Операторы сравнения сравнивают два значения и возвращают boolean:

public class ComparisonOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println("a == b: " + (a == b));
        System.out.println("a != b: " + (a != b));
        System.out.println("a > b: " + (a > b));
        System.out.println("a < b: " + (a < b));
        System.out.println("a >= b: " + (a >= b));
        System.out.println("a <= b: " + (a <= b));

        String s1 = "Привет";
        String s2 = "Привет";
        String s3 = "Мир";

        System.out.println("s1 == s2: " + (s1 == s2));
        System.out.println("s1.equals(s2): " + s1.equals(s2));
        System.out.println("s1.equals(s3): " + s1.equals(s3));
    }
}

Логический оператор AND (&&)

Оператор && (логическое И) возвращает true только когда оба условия истинны. Это как двухзамочный замок: оба ключа должны быть повёрнуты, чтобы открыть дверь.

public class AndOperator {
    public static void main(String[] args) {
        boolean sunny = true;
        boolean warm = true;
        boolean raining = false;

        boolean goSwimming = sunny && warm;
        boolean goHiking = sunny && !raining;

        System.out.println("Идти купаться: " + goSwimming);
        System.out.println("Идти на прогулку: " + goHiking);

        int age = 25;
        boolean hasID = true;
        boolean canEnter = age >= 18 && hasID;

        System.out.println("Можно войти: " + canEnter);
    }
}

Таблица истинности для AND (&&)

Запомните: для AND нужна оба условия true. Достаточно одному быть false, чтобы результат был false.

Логический оператор OR (||)

Оператор || (логическое ИЛИ) возвращает true когда хотя бы одно условие истинно. Это как электрическая цепь с двумя выключателями параллельно: достаточно включить любой, чтобы лампа зажглась.

public class OrOperator {
    public static void main(String[] args) {
        boolean hasTicket = true;
        boolean hasVIP = false;
        boolean hasInvitation = true;

        boolean canEnter = hasTicket || hasVIP || hasInvitation;

        boolean isWeekend = true;
        boolean isHoliday = false;
        boolean dayOff = isWeekend || isHoliday;

        System.out.println("Можно войти: " + canEnter);
        System.out.println("Выходной: " + dayOff);

        int score = 85;
        boolean passed = score >= 60 || score >= 80;

        System.out.println("Экзамен сдан: " + passed);
    }
}

Таблица истинности для OR (||)

Для OR достаточно одного true. Достаточно одному условию быть true, чтобы результат был true.

Логический оператор NOT (!)

Оператор ! (логическое НЕ) инвертирует значение: true становится false, а false — true. Это как перевёртывание выключателя.

public class NotOperator {
    public static void main(String[] args) {
        boolean isDaytime = true;
        boolean isNighttime = !isDaytime;

        boolean isRaining = false;
        boolean isNotRaining = !isRaining;

        System.out.println("День: " + isDaytime);
        System.out.println("Ночь: " + isNighttime);
        System.out.println("Не дождь: " + isNotRaining);

        int age = 15;
        boolean isAdult = age >= 18;
        boolean isMinor = !isAdult;

        System.out.println("Совершеннолетний: " + isAdult);
        System.out.println("Несовершеннолетний: " + isMinor);
    }
}

Таблица истинности для NOT (!)

Приоритет операторов

Приоритет определяет порядок вычислений. NOT (!) имеет наивысший приоритет, затем AND (&&), затем OR (||):

public class PriorityExample {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        boolean c = true;

        boolean result1 = a || b && c;
        System.out.println("a || b && c: " + result1);

        boolean result2 = (a || b) && c;
        System.out.println("(a || b) && c: " + result2);

        boolean result3 = !a && b;
        System.out.println("!a && b: " + result3);

        boolean result4 = !(a && b);
        System.out.println("!(a && b): " + result4);
    }
}

Порядок приоритета (от высшего к низшему):

• ! (NOT) — наивысший приоритет
• && (AND) — средний приоритет
• || (OR) — низкий приоритет

Short-circuit вычисления

Java использует «ленивые» (short-circuit) вычисления для && и ||. Это значит, что второе условие вычисляется только если это необходимо:

Для && (AND):

Если первое условие false — второе НЕ вычисляется, потому что результат и так false.

public class ShortCircuitAnd {
    public static void main(String[] args) {
        int x = 0;
        boolean result = (x != 0) && (10 / x > 2);

        System.out.println("Результат: " + result);

        x = 5;
        result = (x != 0) && (10 / x > 2);
        System.out.println("Результат: " + result);
    }
}

Когда x = 0, первое условие (x != 0) — false. Второе условие (10 / x > 2) НЕ вычисляется, поэтому деления на ноль не происходит!

Для || (OR):

Если первое условие true — второе НЕ вычисляется, потому что результат и так true.

public class ShortCircuitOr {
    public static void main(String[] args) {
        int x = 0;
        boolean result = (x == 0) || (10 / x > 2);

        System.out.println("Результат: " + result);

        x = 5;
        result = (x == 0) || (10 / x > 2);
        System.out.println("Результат: " + result);
    }
}

Когда x = 0, первое условие (x == 0) — true. Второе условие НЕ вычисляется, деления на ноль не происходит!

Составные логические операторы

Помимо основных, существуют составные операторы:

public class CompoundOperators {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        boolean xor = a ^ b;
        System.out.println("XOR (a ^ b): " + xor);

        boolean nand = !(a && b);
        System.out.println("NAND (!(a && b)): " + nand);

        boolean nor = !(a || b);
        System.out.println("NOR (!(a || b)): " + nor);
    }
}

Таблица истинности для XOR (^)

XOR (исключающее ИЛИ) возвращает true только когда операнды различаются. Это полезно для простого шифрования и обмена значений.

boolean в условиях if/else

boolean — основа конструкций условий в Java:

public class BooleanInConditions {
    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;

        if (age >= 18 && hasTicket) {
            System.out.println("Добро пожаловать!");
        } else if (age >= 18) {
            System.out.println("Нужен билет");
        } else {
            System.out.println("Только для взрослых");
        }

        boolean isWeekend = true;
        boolean isHoliday = false;

        if (isWeekend || isHoliday) {
            System.out.println("Можно отдохнуть!");
        } else {
            System.out.println("Рабочий день");
        }

        if (!isHoliday) {
            System.out.println("Нужно работать");
        }
    }
}

Тернарный оператор

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

public class TernaryOperator {
    public static void main(String[] args) {
        int age = 25;
        String status = (age >= 18) ? "взрослый" : "ребёнок";
        System.out.println("Статус: " + status);

        int a = 10, b = 20;
        int max = (a > b) ? a : b;
        System.out.println("Максимум: " + max);

        boolean isPositive = true;
        int value = isPositive ? 1 : -1;
        System.out.println("Значение: " + value);
    }
}

Формат: условие ? значение_если_true : значение_если_false. Это сокращённая запись if/else, когда нужно выбрать одно из двух значений.

Практический пример: калькулятор скидок

public class DiscountCalculator {
    public static void main(String[] args) {
        double price = 5000;
        int age = 25;
        boolean isVIP = true;
        boolean isBirthday = false;
        int purchaseCount = 12;

        boolean isStudent = age >= 18 && age <= 25;
        boolean hasLoyalty = purchaseCount >= 10;

        double discount = 0;

        if (isVIP) {
            discount = 15;
        } else if (isStudent) {
            discount = 10;
        }

        if (isBirthday) {
            discount += 5;
        }

        if (hasLoyalty) {
            discount += 3;
        }

        discount = Math.min(discount, 30);

        double finalPrice = price * (1 - discount / 100);

        System.out.println("=== Калькулятор скидок ===");
        System.out.printf("Цена: %.2f руб.%n", price);
        System.out.println("VIP: " + isVIP);
        System.out.println("Студент: " + isStudent);
        System.out.println("День рождения: " + isBirthday);
        System.out.println("Постоянный клиент: " + hasLoyalty);
        System.out.printf("Скидка: %.0f%%%n", discount);
        System.out.printf("Итого: %.2f руб.%n", finalPrice);
    }
}

Частые ошибки новичков

Ошибка 1: Путаница = и ==

boolean flag = true;
if (flag = false) { ... }   // Присваивает false! Всегда false.
if (flag == false) { ... }  // Сравнивает. Правильно.

Ошибка 2: Использование чисел вместо boolean

int x = 1;
if (x) { ... }        // ОШИБКА компиляции!
if (x != 0) { ... }  // Правильно

Ошибка 3: Избыточные сравнения

boolean flag = true;
if (flag == true) { ... }  // Избыточно!
if (flag) { ... }          // Лучше
if (!flag) { ... }         // Для false

Итоги урока

• boolean хранит только true или false
• Операторы сравнения: ==, !=, >, <, >=, <=
• Логические операторы: && (AND), || (OR), ! (NOT)
• Таблицы истинности: AND — оба true, OR — хотя бы один true, NOT — инверсия
• Short-circuit: && останавливается на первом false, || — на первом true
• Приоритет: ! > && > ||
• Используйте скобки для ясности
• Тернарный оператор ?: для компактного выбора значения
• Не путайте = (присваивание) и == (сравнение)
• Пишите if (flag), а не if (flag == true)

← Предыдущий урок: Символы и строки Следующий урок: Арифметические операции →