LabEx
ВходРегистрация

Как проверить, является ли булевая переменная истинной в Java

JavaBeginner
Практиковаться сейчас

Введение

В этом практическом занятии (лабораторной работе) вы научитесь проверять, является ли логическая (булева) переменная равной true в Java. Мы рассмотрим основной метод с использованием оператора равенства, углубимся в обработку оберточного класса Boolean и обсудим, как управлять потенциальными нулевыми значениями.

С помощью практических примеров вы получите практический опыт в написании условной логики на основе булевых значений, обеспечивая надежность вашего Java-кода и эффективную обработку различных сценариев.

Использование оператора равенства для проверки на истинность

На этом этапе мы рассмотрим, как проверить, является ли булева переменная равной true в Java, используя оператор равенства. Хотя это может показаться простым, понимание нюансов важно для написания чистого и корректного кода.

В Java тип данных boolean может принимать одно из двух значений: true или false. Когда у вас есть булева переменная, вам часто нужно проверить ее значение, чтобы принимать решения в программе.

Самым распространенным способом проверить, является ли булева переменная равной true, является использование оператора равенства ==.

Создадим простую Java-программу, чтобы продемонстрировать это.

  1. Откройте файл HelloJava.java в редакторе WebIDE, если он еще не открыт.

  2. Замените все содержимое файла следующим кодом:

    public class HelloJava {
    public static void main(String[] args) {
        boolean isJavaFun = true;

        if (isJavaFun == true) {
            System.out.println("Java is fun!");
        } else {
            System.out.println("Java is not fun.");
        }
    }
}

    Рассмотрим новые части этого кода:

    • boolean isJavaFun = true;: Эта строка объявляет булеву переменную с именем isJavaFun и инициализирует ее значением true.
    • if (isJavaFun == true): Это оператор if. Он проверяет, является ли условие в скобках равным true. Условие isJavaFun == true использует оператор равенства == для сравнения значения переменной isJavaFun с булевым литералом true.
    • System.out.println("Java is fun!");: Эта строка будет выполнена, если условие isJavaFun == true равно true.
    • else: Это ключевое слово представляет блок кода, который будет выполнен, если условие оператора if равно false.
    • System.out.println("Java is not fun.");: Эта строка будет выполнена, если условие isJavaFun == true равно false.

  3. Сохраните файл (Ctrl+S или Cmd+S).

  4. Скомпилируйте программу с помощью команды javac в терминале:

    javac HelloJava.java

    Если нет ошибок, в директории ~/project будет создан файл HelloJava.class.

  5. Запустите скомпилированную программу с помощью команды java:

    java HelloJava

    Вы должны увидеть следующий вывод:

    Java is fun!

    Это подтверждает, что условие оператора if isJavaFun == true было оценено как true, и соответствующее сообщение было выведено.

Хотя использование == true является абсолютно допустимым и легко понятным, в Java вы можете упростить проверку на true. Поскольку оператор if уже оценивает выражение в скобках как булево значение, вы можете напрямую использовать саму булеву переменную в качестве условия.

Изменим код, чтобы использовать этот упрощенный подход:

  1. Откройте файл HelloJava.java снова в редакторе.

  2. Измените оператор if на следующий:

    if (isJavaFun) {
    System.out.println("Java is fun!");
} else {
    System.out.println("Java is not fun.");
}

    Обратите внимание, что мы удалили == true. Оператор if (isJavaFun) эквивалентен if (isJavaFun == true).

  3. Сохраните файл.

  4. Скомпилируйте модифицированную программу:

    javac HelloJava.java

  5. Запустите программу снова:

    java HelloJava

    Вы получите тот же вывод:

    Java is fun!

    Это показывает, что использование булевой переменной напрямую в условии оператора if является более кратким и идиоматичным способом проверить, является ли она равной true.

В целом, вы можете использовать оператор равенства == true для проверки, является ли булево значение равным true, но более распространенным и чистым способом является просто использование самой булевой переменной в качестве условия в операторе if.

Тестирование с использованием обёрточного класса Boolean

На предыдущем этапе мы работали с примитивным типом boolean. В Java также есть соответствующий оберточный класс, называемый Boolean. Оборточные классы позволяют использовать примитивные типы данных как объекты. Это особенно полезно при работе с коллекциями или когда вам нужно представить булевое значение, которое может быть равно null.

Класс Boolean имеет два предопределенных объекта для булевых значений: Boolean.TRUE и Boolean.FALSE. Это константные объекты, представляющие булевы значения true и false соответственно.

При работе с объектами Boolean вы по-прежнему можете использовать оператор равенства == для их сравнения. Однако важно понимать, как работает == с объектами. Для объектов == проверяет, ссылаются ли две переменные на один и тот же объект в памяти, а не просто имеют ли они одинаковые значения.

Изменим нашу программу, чтобы использовать оберточный класс Boolean и посмотреть, как ведет себя оператор равенства.

  1. Откройте файл HelloJava.java в редакторе WebIDE.

  2. Замените код следующим:

    public class HelloJava {
    public static void main(String[] args) {
        Boolean isJavaFunObject = Boolean.TRUE;

        if (isJavaFunObject == Boolean.TRUE) {
            System.out.println("Java is fun (using Boolean.TRUE)!");
        } else {
            System.out.println("Java is not fun (using Boolean.TRUE).");
        }

        Boolean anotherBooleanObject = true; // Autoboxing

        if (anotherBooleanObject == Boolean.TRUE) {
             System.out.println("Another boolean object is true!");
        } else {
             System.out.println("Another boolean object is not true.");
        }
    }
}

    Рассмотрим изменения:

    • Boolean isJavaFunObject = Boolean.TRUE;: Мы объявляем переменную типа Boolean и присваиваем ей константу Boolean.TRUE.
    • if (isJavaFunObject == Boolean.TRUE): Мы используем оператор равенства == для сравнения нашего объекта Boolean с константой Boolean.TRUE. Поскольку isJavaFunObject присвоено значение Boolean.TRUE, они ссылаются на один и тот же объект, поэтому это условие будет равно true.
    • Boolean anotherBooleanObject = true;: Эта строка демонстрирует "автоупаковку" (autoboxing). Java автоматически преобразует примитивное значение boolean true в объект Boolean.
    • if (anotherBooleanObject == Boolean.TRUE): Мы снова используем == для сравнения anotherBooleanObject с Boolean.TRUE. Из-за того, как работает автоупаковка и кэширование значений Boolean в Java, для значений true и false автоупакованные объекты Boolean часто ссылаются на те же кэшированные экземпляры, что и Boolean.TRUE и Boolean.FALSE. Поэтому это условие также, скорее всего, будет равно true.

  3. Сохраните файл.

  4. Скомпилируйте программу:

    javac HelloJava.java

  5. Запустите программу:

    java HelloJava

    Вы должны увидеть следующий вывод:

    Java is fun (using Boolean.TRUE)!
Another boolean object is true!

    Это подтверждает, что использование == с Boolean.TRUE работает как ожидается в этих случаях, потому что переменные, скорее всего, ссылаются на один и тот же базовый объект Boolean.TRUE.

Однако полагаться на == для сравнения объектов Boolean может быть рискованным в более сложных сценариях, особенно если объекты Boolean создаются различными способами или приходят из разных источников. Более безопасным и рекомендуемым способом сравнения объектов Boolean на равенство значений является использование метода .equals().

Изменим код, чтобы использовать .equals().

  1. Откройте файл HelloJava.java в редакторе.

  2. Измените операторы if, чтобы использовать .equals():

    public class HelloJava {
    public static void main(String[] args) {
        Boolean isJavaFunObject = Boolean.TRUE;

        if (isJavaFunObject.equals(Boolean.TRUE)) {
            System.out.println("Java is fun (using equals)!");
        } else {
            System.out.println("Java is not fun (using equals).");
        }

        Boolean anotherBooleanObject = true; // Autoboxing

        if (anotherBooleanObject.equals(Boolean.TRUE)) {
             System.out.println("Another boolean object is true (using equals)!");
        } else {
             System.out.println("Another boolean object is not true (using equals).");
        }
    }
}

    Мы заменили == Boolean.TRUE на .equals(Boolean.TRUE). Метод .equals() сравнивает значения объектов, а не их местоположение в памяти.

  3. Сохраните файл.

  4. Скомпилируйте программу:

    javac HelloJava.java

  5. Запустите программу:

    java HelloJava

    Вы должны увидеть следующий вывод:

    Java is fun (using equals)!
Another boolean object is true (using equals)!

    Использование .equals() является стандартным и наиболее безопасным способом сравнения объектов Boolean на равенство значений.

В целом, хотя == может работать для сравнения объектов Boolean с Boolean.TRUE из-за кэширования, метод .equals() является предпочтительным и более надежным способом проверки, представляет ли объект Boolean значение true.

Обработка нулевых значений Boolean

На предыдущем этапе мы узнали о оберточном классе Boolean. Одно из ключевых отличий между примитивным типом boolean и оберточным классом Boolean заключается в том, что переменная типа Boolean может иметь значение null, в то время как примитивный boolean этого сделать не может. Обработка значений null является важной частью программирования на Java, чтобы избежать ошибок NullPointerException.

Ошибка NullPointerException возникает, когда вы пытаетесь использовать переменную, которая в данный момент ссылается на null, как если бы это был действительный объект. Например, вызов метода для объекта, равного null, приведет к ошибке NullPointerException.

При проверке, является ли объект Boolean равным true, необходимо быть осторожным, если объект может быть null.

Давайте посмотрим, что произойдет, если мы попытаемся проверить null объект Boolean с использованием методов, которые мы узнали до сих пор.

  1. Откройте файл HelloJava.java в редакторе WebIDE.

  2. Замените код следующим:

    public class HelloJava {
    public static void main(String[] args) {
        Boolean nullableBoolean = null;

        // Attempting to use == with null
        if (nullableBoolean == true) {
            System.out.println("This won't be printed.");
        } else {
            System.out.println("Using == with null Boolean.");
        }

        // Attempting to use .equals() with null
        // This will cause a NullPointerException!
        // if (nullableBoolean.equals(Boolean.TRUE)) {
        //     System.out.println("This will not be reached.");
        // } else {
        //     System.out.println("This will not be reached either.");
        // }
    }
}

    В этом коде:

    • Boolean nullableBoolean = null;: Мы объявляем переменную типа Boolean и явно устанавливаем ее значение в null.
    • if (nullableBoolean == true): Мы используем оператор равенства == для сравнения null объекта Boolean с примитивным значением true. При сравнении объекта Boolean (даже если он равен null) с примитивным boolean, Java выполняет "распаковку" (unboxing). Она пытается преобразовать объект Boolean в примитивный boolean. Если объект Boolean равен null, этот процесс распаковки приводит к ошибке NullPointerException.
    • Закомментированная проверка с использованием .equals() также вызовет ошибку NullPointerException, потому что вы пытаетесь вызвать метод .equals() для объекта, равного null (nullableBoolean).

  3. Сохраните файл.

  4. Скомпилируйте программу:

    javac HelloJava.java

  5. Запустите программу:

    java HelloJava

    В терминале вы увидите сообщение об ошибке, указывающее на NullPointerException:

    Exception in thread "main" java.lang.NullPointerException
    at HelloJava.main(HelloJava.java:6)

    Это показывает, что прямое сравнение потенциально null объекта Boolean с примитивным boolean с использованием == или вызов .equals() для него может привести к ошибке NullPointerException.

Для безопасной обработки потенциально null объектов Boolean вы всегда должны проверять, является ли объект null перед попыткой распаковать его или вызвать методы для него.

Вот как вы можете безопасно проверить, является ли объект Boolean равным true:

  1. Откройте файл HelloJava.java в редакторе.

  2. Замените код следующим:

    public class HelloJava {
    public static void main(String[] args) {
        Boolean nullableBoolean = null;
        Boolean trueBoolean = Boolean.TRUE;
        Boolean falseBoolean = Boolean.FALSE;

        // Safely check if nullableBoolean is true
        if (nullableBoolean != null && nullableBoolean == true) {
            System.out.println("nullableBoolean is true (safe check).");
        } else {
            System.out.println("nullableBoolean is not true or is null (safe check).");
        }

        // Safely check if trueBoolean is true
        if (trueBoolean != null && trueBoolean == true) {
            System.out.println("trueBoolean is true (safe check).");
        } else {
            System.out.println("trueBoolean is not true or is null (safe check).");
        }

        // Safely check if falseBoolean is true
        if (falseBoolean != null && falseBoolean == true) {
            System.out.println("falseBoolean is true (safe check).");
        } else {
            System.out.println("falseBoolean is not true or is null (safe check).");
        }

        // Alternative safe check using equals
        if (Boolean.TRUE.equals(nullableBoolean)) {
             System.out.println("nullableBoolean is true (safe equals check).");
        } else {
             System.out.println("nullableBoolean is not true or is null (safe equals check).");
        }

         if (Boolean.TRUE.equals(trueBoolean)) {
             System.out.println("trueBoolean is true (safe equals check).");
         } else {
             System.out.println("trueBoolean is not true or is null (safe equals check).");
         }
    }
}

    В этом обновленном коде:

    • if (nullableBoolean != null && nullableBoolean == true): Мы сначала проверяем, не является ли nullableBoolean равным null с использованием nullableBoolean != null. Оператор && означает, что вторая часть условия (nullableBoolean == true) будет оценена только в том случае, если первая часть (nullableBoolean != null) равна true. Это предотвращает ошибку NullPointerException. Если nullableBoolean равен null, первая часть условия равна false, и все условие равно false без оценки второй части.
    • if (Boolean.TRUE.equals(nullableBoolean)): Это еще один безопасный способ проверить, является ли объект Boolean равным true, даже если он равен null. Вызывая метод .equals() для известного не-null объекта Boolean.TRUE и передавая в качестве аргумента потенциально null объект nullableBoolean, мы избавляемся от ошибки NullPointerException. Метод .equals() разработан так, чтобы корректно обрабатывать аргументы, равные null; Boolean.TRUE.equals(null) просто вернет false.

  3. Сохраните файл.

  4. Скомпилируйте программу:

    javac HelloJava.java

  5. Запустите программу:

    java HelloJava

    Вы должны увидеть следующий вывод:

    nullableBoolean is not true or is null (safe check).
trueBoolean is true (safe check).
falseBoolean is not true or is null (safe check).
nullableBoolean is not true or is null (safe equals check).
trueBoolean is true (safe equals check).

    Это демонстрирует, как безопасно проверить значение объекта Boolean, даже если оно может быть null, используя как проверку != null в сочетании с == true, так и метод Boolean.TRUE.equals().

Всегда помните о возможности наличия null при работе с объектами Boolean, чтобы избежать ошибок во время выполнения программы.

Резюме

В этом практическом занятии мы научились проверять, является ли булевая переменная равной true в Java. Мы начали с использования оператора равенства == для прямого сравнения булевой переменной с булевым литералом true. Это самый распространенный и простой способ проверки значения примитивного булевого типа.

Мы также изучили, как работать с оберточными объектами Boolean, которые могут быть равны null. Мы узнали, что прямое сравнение объекта Boolean с true с использованием == может не работать так, как ожидается из-за идентичности объектов. Вместо этого мы должны использовать метод equals() или распаковать объект Boolean в его примитивное булевое значение перед сравнением. Наконец, мы рассмотрели важность обработки потенциальной ошибки NullPointerException при работе с nullable объектами Boolean, проверяя на null перед попыткой получить их значение.

Связанные Java Курсы
Java для начинающих

Java для начинающих

java
Упражнения по программированию на Java

Упражнения по программированию на Java

java
Массовая вставка данных в расписание курсов

Массовая вставка данных в расписание курсов

java