Как проверить, является ли объект null в Java

Введение

В этом практическом занятии (лабораторной работе) вы научитесь основным методам проверки объекта на null в Java, что является фундаментальным навыком для предотвращения ошибок NullPointerException. Мы начнем с изучения самого простого метода: использования оператора равенства (==) для непосредственного сравнения ссылки на переменную с null.

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

Skills Graph

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

На этом этапе мы рассмотрим один из самых простых способов проверки на null в Java: использование оператора равенства (==). Понимание того, как обрабатывать null, является важной частью программирования на Java для предотвращения ошибок.

В Java null - это специальное значение, которое означает, что ссылка на переменную не указывает на какой-либо объект. Представьте переменную как коробку, а объект - как то, что вы кладете в коробку. Если коробка пуста, переменная имеет значение null. Попытка использовать ссылку на null (например, попытка использовать что - то из пустой коробки) часто приводит к ошибке NullPointerException, которая является распространенной и раздражающей для начинающих программистов.

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

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

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

   public class HelloJava {
       public static void main(String[] args) {
           String message = null; // Declaring a String variable and setting it to null
   
           // Checking if the message variable is null using the equality operator
           if (message == null) {
               System.out.println("The message is null.");
           } else {
               System.out.println("The message is: " + message);
           }
   
           message = "Hello, World!"; // Assigning a String object to the variable
   
           // Checking again after assigning a value
           if (message == null) {
               System.out.println("The message is null.");
           } else {
               System.out.println("The message is: " + message);
           }
       }
   }

   В этом коде:

   • Мы объявляем переменную типа String с именем message и изначально устанавливаем ее значение в null.
   • Мы используем оператор if с оператором равенства (==), чтобы проверить, является ли message равным null.
   • Если message == null истинно, мы выводим "The message is null.".
   • Если это ложно, мы выводим само сообщение.
   • Затем мы присваиваем строковое значение "Hello, World!" переменной message.
   • Мы снова выполняем проверку на null, чтобы увидеть разный вывод.

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

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

   javac HelloJava.java

   Если нет ошибок, компиляция прошла успешно.

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

   java HelloJava

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

   The message is null.
   The message is: Hello, World!

   Этот вывод подтверждает, что наша проверка на null с использованием == работает правильно. Когда message был равен null, первое условие if было истинным. После того, как мы присвоили значение, второе условие if было ложным, и был выполнен блок else.

Использование оператора равенства (==) является стандартным и рекомендуемым способом проверки, является ли ссылка на переменную равной null в Java. Он прост, понятен и эффективен.

Совмещение проверок на null и на тип объекта

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

Java предоставляет оператор instanceof для проверки, является ли объект экземпляром определенного класса или реализует определенный интерфейс. Мы можем сочетать эту проверку с проверкой на null с помощью логического оператора И (&&).

Давайте модифицируем нашу программу HelloJava.java, чтобы продемонстрировать это.

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

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

   public class HelloJava {
       public static void main(String[] args) {
           Object myObject = "This is a String"; // Declaring an Object variable
   
           // Checking if myObject is not null AND is an instance of String
           if (myObject != null && myObject instanceof String) {
               String message = (String) myObject; // Casting the Object to a String
               System.out.println("The object is a non-null String: " + message);
           } else {
               System.out.println("The object is null or not a String.");
           }
   
           myObject = null; // Setting the object to null
   
           // Checking again after setting to null
           if (myObject != null && myObject instanceof String) {
               String message = (String) myObject;
               System.out.println("The object is a non-null String: " + message);
           } else {
               System.out.println("The object is null or not a String.");
           }
   
           myObject = 123; // Setting the object to an Integer
   
           // Checking again after setting to an Integer
           if (myObject != null && myObject instanceof String) {
               String message = (String) myObject;
               System.out.println("The object is a non-null String: " + message);
           } else {
               System.out.println("The object is null or not a String.");
           }
       }
   }

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

   • Мы объявляем переменную myObject типа Object. Object - это базовый класс для всех классов в Java, поэтому он может хранить ссылку на любой объект.
   • Сначала мы присваиваем переменной myObject строку (String).
   • Условие if myObject != null && myObject instanceof String проверяет два условия:
     • myObject != null: Ссылка на объект не равна null?
     • myObject instanceof String: Объект является экземпляром класса String?
   • Оператор && означает, что оба условия должны быть истинными, чтобы выполнился код внутри блока if.
   • Если оба условия истинны, мы преобразуем (cast) myObject в String с помощью (String) myObject и выводим сообщение. Преобразование необходимо, потому что myObject объявлен как Object, и мы должны сообщить компилятору, что мы знаем, что на самом деле это String, чтобы можно было обращаться с ним как с String.
   • Если хотя бы одно из условий ложно (объект равен null или не является String), выполняется блок else.
   • Затем мы тестируем условие if, установив myObject равным null, а затем равным Integer (который не является String).

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

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

   javac HelloJava.java

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

   java HelloJava

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

   The object is a non-null String: This is a String
   The object is null or not a String.
   The object is null or not a String.

   Этот вывод показывает, что условие if правильно определило, когда объект был не null и являлся String, а когда он был либо null, либо не String.

Совмещение проверок != null и instanceof является стандартной практикой в Java, когда вам нужно безопасно работать с объектами определенного типа, которые могут быть равны null.

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

На этом этапе мы рассмотрим более современный подход к обработке потенциальных значений null в Java, введенный в Java 8: класс Optional. Optional представляет собой контейнерный объект, который может содержать или не содержать не-null значение. Он предоставляет способ более явно представлять наличие или отсутствие значения, что помогает снизить риск возникновения ошибки NullPointerException.

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

Давайте модифицируем нашу программу HelloJava.java для использования Optional.

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

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

   import java.util.Optional;
   
   public class HelloJava {
       public static void main(String[] args) {
           // Creating an Optional that contains a value
           Optional<String> optionalMessageWithValue = Optional.of("Hello from Optional!");
   
           // Creating an Optional that is empty (represents null)
           Optional<String> optionalMessageWithoutValue = Optional.empty();
   
           // Handling the Optional with a value
           if (optionalMessageWithValue.isPresent()) {
               String message = optionalMessageWithValue.get(); // Get the value if present
               System.out.println("Optional with value: " + message);
           } else {
               System.out.println("Optional with value is empty.");
           }
   
           // Handling the Optional without a value
           if (optionalMessageWithoutValue.isPresent()) {
               String message = optionalMessageWithoutValue.get();
               System.out.println("Optional without value: " + message);
           } else {
               System.out.println("Optional without value is empty.");
           }
   
           // A more concise way to handle Optional using ifPresent
           optionalMessageWithValue.ifPresent(msg -> System.out.println("Using ifPresent: " + msg));
   
           // Using orElse to provide a default value if Optional is empty
           String messageOrDefault = optionalMessageWithoutValue.orElse("Default Message");
           System.out.println("Using orElse: " + messageOrDefault);
       }
   }

   В этом коде:

   • Мы импортируем класс Optional.
   • Мы создаем Optional<String>, содержащий значение, с помощью Optional.of(). Обратите внимание, что Optional.of() выбросит исключение NullPointerException, если вы передадите ему null. Если значение может быть null, используйте вместо этого Optional.ofNullable().
   • Мы создаем пустой Optional<String> с помощью Optional.empty().
   • Мы используем optionalMessageWithValue.isPresent() для проверки, содержит ли Optional значение. Если содержит, мы можем получить это значение с помощью optionalMessageWithValue.get(). Обратите внимание: вызов get() для пустого Optional вызовет исключение NoSuchElementException.
   • Мы демонстрируем аналогичную обработку пустого Optional.
   • Мы показываем метод ifPresent(), который выполняет заданное действие только в том случае, если значение присутствует. Это более чистый способ выполнения действия над значением, если оно существует.
   • Мы показываем метод orElse(), который возвращает значение, если оно присутствует, в противном случае возвращает значение по умолчанию. Это полезно для предоставления резервных значений.

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

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

   javac HelloJava.java

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

   java HelloJava

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

   Optional with value: Hello from Optional!
   Optional without value is empty.
   Using ifPresent: Hello from Optional!
   Using orElse: Default Message

   Этот вывод демонстрирует, как Optional можно использовать для более явной и безопасной обработки наличия или отсутствия значений по сравнению с традиционными проверками на null. Хотя Optional не заменяет все проверки на null, он представляет собой ценный инструмент для проектирования API и написания кода, где отсутствие значения является допустимым и ожидаемым сценарием.

Резюме

В этом практическом занятии мы изучили основные методы проверки объекта на null в Java. Мы начали с рассмотрения самого простого способа: использования оператора равенства (==) для прямого сравнения ссылки на переменную с null. Эта простая проверка является важной частью предотвращения ошибок NullPointerException.

Затем мы перешли к более сложным сценариям, хотя в предоставленном материале описан только базовый метод сравнения на равенство. В полном практическом занятии, вероятно, также были бы рассмотрены комбинирование проверок на null с проверками типа объекта и использование класса Optional — современной функции Java, предназначенной для более элегантной и выразительной обработки потенциальных значений null, что способствует написанию более чистого и безопасного кода.