Skip to content

7. Логические операторы

Введение

Логические операторы в Java используются для выполнения операций с булевыми значениями. Они играют ключевую роль в управлении потоком выполнения программы и принятии решений на основе определенных условий.

Тип данных boolean

В Java существует специальный тип данных для представления логических значений - boolean. Переменные этого типа могут принимать только два значения: true (истина) или false (ложь).

Пример объявления булевых переменных:

boolean isJavaFun = true;
boolean isCodingHard = false;

Логические операторы

Java предоставляет несколько логических операторов для работы с булевыми значениями:

  1. AND (&&): возвращает true, если оба операнда true
  2. OR (||): возвращает true, если хотя бы один из операндов true
  3. NOT (!): инвертирует значение операнда
  4. XOR (^): возвращает true, если операнды различны

Примеры использования логических операторов:

boolean a = true;
boolean b = false;

System.out.println("a && b = " + (a && b));  // false
System.out.println("a || b = " + (a || b));  // true
System.out.println("!a = " + (!a));          // false
System.out.println("a ^ b = " + (a ^ b));    // true

Таблицы истинности

Таблицы истинности помогают понять, как работают логические операторы с различными комбинациями входных данных.

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

A B A && B
0 0 0
0 1 0
1 0 0
1 1 1

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

A B A || B
0 0 0
0 1 1
1 0 1
1 1 1

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

A !A
0 1
1 0

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

A B A ^ B
0 0 0
0 1 1
1 0 1
1 1 0

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

Важно помнить о приоритете логических операторов:

  1. ! (NOT)
  2. && (AND)
  3. || (OR)

Для изменения порядка выполнения операций используются круглые скобки.

Пример: Булев калькулятор

Теперь давайте реализуем простой булев калькулятор, который принимает два операнда и оператор, а затем выводит результат.

import java.util.Scanner;

public class BooleanCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Введите выражение (например, 1 & 0):");

        int operand1 = scanner.nextInt();
        String operator = scanner.next();
        int operand2 = scanner.nextInt();

        boolean result;

        switch (operator) {
            case "&":
                result = (operand1 == 1) && (operand2 == 1);
                System.out.println("Результат: " + result);
                break;
            case "|":
                result = (operand1 == 1) || (operand2 == 1);
                System.out.println("Результат: " + result);
                break;
            default:
                System.out.println("Неизвестный оператор");
        }

        scanner.close();
    }
}

Этот калькулятор принимает два операнда (1 или 0) и оператор (&или|`) и выводит результат операции или сообщение "Неизвестный оператор", если введен некорректный оператор.

Побитовые операторы vs Логические операторы

В Java, помимо логических операторов && и ||, существуют также побитовые операторы & и |. Хотя они могут использоваться с булевыми значениями, между ними есть важные различия:

Побитовые операторы (& и |)

  1. Побитовое AND (&): Выполняет операцию AND для каждого бита операндов.
  2. Побитовое OR (|): Выполняет операцию OR для каждого бита операндов.

При использовании с булевыми значениями, они работают аналогично логическим операторам, но с одним важным отличием: они всегда вычисляют оба операнда.

Логические операторы (&& и ||)

  1. Логическое AND (&&): Возвращает true, если оба операнда true.
  2. Логическое OR (||): Возвращает true, если хотя бы один из операндов true.

Ключевое отличие: эти операторы используют короткое замыкание (short-circuit evaluation).

Ключевые различия

  1. Короткое замыкание:
  2. && и || используют короткое замыкание. Если результат может быть определен по первому операнду, второй операнд не вычисляется.

  3. & и | всегда вычисляют оба операнда.

  4. Производительность:

  5. && и || могут быть более эффективными, так как они могут пропустить вычисление второго операнда.

  6. & и | всегда вычисляют оба операнда, что может быть менее эффективно.

  7. Применение:

  8. && и || обычно используются в условных выражениях.
  9. & и | чаще используются для побитовых операций с целыми числами, но могут применяться и к булевым значениям.

Пример:

public class OperatorComparison {
    public static void main(String[] args) {
        System.out.println("Логические операторы:");
        System.out.println(false && methodReturningBoolean()); // Метод не вызывается
        System.out.println(true || methodReturningBoolean()); // Метод не вызывается

        System.out.println("\nПобитовые операторы:");
        System.out.println(false & methodReturningBoolean()); // Метод вызывается
        System.out.println(true | methodReturningBoolean()); // Метод вызывается
    }

    public static boolean methodReturningBoolean() {
        System.out.println("Метод был вызван");
        return true;
    }
}

В этом примере methodReturningBoolean() не будет вызван при использовании && и ||, если результат уже определен первым операндом. Однако при использовании & и | метод будет вызван в обоих случаях.

Заключение

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

Это полная лекция о логических операторах в Java, включающая теорию и практический пример в виде булева калькулятора. Давайте разберем основные моменты:

  1. Мы начали с введения в тему и объяснения типа данных boolean.
  2. Затем мы рассмотрели основные логические операторы: AND, OR, NOT и XOR.
  3. Мы привели таблицы истинности для каждого оператора, чтобы наглядно показать, как они работают с разными комбинациями входных данных.
  4. Обсудили приоритет операторов, что важно для правильного построения сложных логических выражений.
  5. В конце мы реализовали простой булев калькулятор, который демонстрирует практическое применение логических операторов.

пример из урока

https://gitlab.com/synergy9980417/tema1_urok1_7/