Краткий ответ

Оператор && вычисляет операнды слева направо. Правый операнд вычисляется только если левый дал значение true; при false результат уже известен и правая часть пропускается.

Это называется коротким замыканием. Поэтому правая часть может не выполнить побочные эффекты и не вызвать исключение, которое возникло бы при её вычислении.

Исторический контекст

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

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

Постановка проблемы

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

Если поменять операнды местами, поведение может измениться: выражение начнёт выполнять опасную операцию раньше проверки. Поэтому порядок условий является частью логики программы, а не только вопросом оформления.

Подробное решение

Java сначала вычисляет левый операнд. Если он равен false, вычисление завершается результатом false, а правый операнд не вычисляется. Если левый операнд равен true, Java вычисляет правый и использует его значение как результат всего выражения.

Операнды должны иметь тип boolean либо Boolean. При использовании Boolean выполняется распаковка в boolean; если значение равно null, возникает NullPointerException в момент распаковки.

Короткое замыкание гарантировано правилами языка, поэтому это не оптимизация JVM, на которую можно случайно рассчитывать. Для логических операндов оператор & отличается тем, что вычисляет обе стороны независимо от значения левой.

class Demo {
    static boolean check() {
        System.out.println("check");
        return true;
    }

    public static void main(String[] args) {
        boolean authorized = false;
        if (authorized && check()) {
            System.out.println("allowed");
        }
    }
}

В этом примере check() не вызывается: после authorized == false результат выражения уже известен. Если заменить && на &, метод будет вызван, даже несмотря на ложное левое условие.

Ситуация из практики

В обработчике HTTP-запроса нужно проверить наличие пользователя и его право доступа. Возможны три варианта: разнести проверки на вложенные if, вызвать обе проверки заранее или использовать && в правильном порядке.

Вложенные if явно выражают зависимости, но увеличивают объём кода. Предварительный вызов обеих проверок проще визуально, однако может привести к обращению к отсутствующему пользователю или к ненужному запросу к базе данных.

Выбором обычно становится user != null && user.hasPermission(). Он сохраняет порядок зависимостей, не вызывает метод для отсутствующего пользователя и кратко выражает требуемое условие. При этом проверки с важными побочными эффектами лучше выносить в отдельные шаги, чтобы их порядок был очевиден.

Что кандидаты часто упускают

Что произойдёт, если левый операнд имеет тип Boolean и равен null?

До логического сравнения Java должна распаковать Boolean в примитивный boolean. Распаковка null вызывает NullPointerException, поэтому короткое замыкание не спасает автоматически: исключение возникает уже при вычислении левого операнда.
Чем && отличается от &, если оба операнда имеют логический тип?

&& применяет короткое замыкание и может не вычислить правую часть. & вычисляет оба операнда, поэтому способен вызвать ненужный метод, изменить состояние или выбросить исключение. Для целочисленных типов & дополнительно имеет смысл побитовой операции, тогда как && применяется только к логическим значениям.
Гарантирует ли && результат типа boolean, если операнды имеют тип Boolean?

Да, логический оператор после распаковки операндов формирует примитивный результат boolean. Это отличается от операций, которые могут сохранить ссылочный тип или вернуть null: выражение с && не возвращает объект Boolean и не может иметь результат null при успешно завершившемся вычислении.