Operadores Lógicos em Java: &&, ||, !

Os operadores lógicos combinam valores boolean em testes mais complexos. Java fornece três: AND (&&), OR (||) e NOT (!). A principal característica de && e || — o fato de realizarem curto-circuito — é o que os torna seguros de usar mesmo quando um operando pode lançar uma exceção.

Normalmente você constrói os operandos boolean a partir de operadores de comparação (como >= ou !=) e os une com os operadores lógicos desta página. Esta página aborda cada operador, a avaliação de curto-circuito, a precedência de operadores, os padrões mais comuns no mundo real e as leis de De Morgan.

Os três operadores

Operador	Nome	Resultado
`&&`	AND	`true` somente se ambos os operandos forem `true`
`\|\|`	OR	`true` se pelo menos um operando for `true`
`!`	NOT	inverte um `boolean` — `!true` é `false`

O comportamento completo cabe em uma pequena tabela verdade:

`a`	`b`	`a && b`	`a \|\| b`	`!a`
`true`	`true`	`true`	`true`	`false`
`true`	`false`	`false`	`true`	`false`
`false`	`true`	`false`	`true`	`true`
`false`	`false`	`false`	`false`	`true`

boolean isAdult = age >= 18;
boolean hasTicket = ticket != null;

if (isAdult && hasTicket) {
    enterCinema();
}

if (isHoliday || isWeekend) {
    sleepIn();
}

if (!isLoggedIn) {
    redirectToLogin();
}

Nota

Os operadores lógicos funcionam apenas com valores boolean, não com números. Java não tem conceito de "truthy" ou "falsy" — if (count) é um erro de compilação; escreva if (count > 0) em vez disso. Não confunda &&/|| lógicos com o operador de comparação ==: a comparação produz o boolean, os operadores lógicos combinam vários deles.

Avaliação de curto-circuito

&& avalia o lado direito somente se o lado esquerdo for true. Se o lado esquerdo for false, o resultado já é conhecido e o direito é ignorado:

boolean leftFalse = false && expensiveCall();   // expensiveCall() never runs

|| faz o oposto — ignora o lado direito se o esquerdo for true:

boolean leftTrue = true || expensiveCall();     // expensiveCall() never runs

Isso é essencial para verificações de null:

if (user != null && user.isActive()) { ... }

Se user for null, o lado direito é ignorado — sem NullPointerException. Inverter a ordem causaria uma falha:

if (user.isActive() && user != null) { ... }   // NPE when user is null

A regra geral: coloque a verificação mais barata, mais segura ou com maior probabilidade de falhar primeiro.

`&` e `|` sem curto-circuito

Java também possui & e | (um único caractere). Com boolean eles calculam o mesmo AND/OR, mas sempre avaliam os dois lados. Você raramente vai querer isso — eles existem principalmente para as variantes bitwise em inteiros (abordadas em Java Bitwise Operators).

boolean a = false & expensiveCall();   // expensiveCall() DOES run
boolean b = true | expensiveCall();    // expensiveCall() DOES run

Se você se pegar usando & ou | com boolean, quase certamente é && e || que você quer.

Combinando operadores

Você pode encadear operadores lógicos para construir qualquer teste boolean:

boolean validAge = age >= 13 && age < 120;
boolean validUser = (name != null && !name.isBlank()) && validAge;

if (isWeekend || (isHoliday && !isWorkRequired)) {
    relax();
}

! tem a maior precedência, depois &&, depois ||. Ao misturá-los, adicione parênteses para maior clareza, mesmo quando não forem estritamente necessários.

Padrões comuns

Verificações de intervalo — combine dois testes relacionais com &&:

if (x >= 0 && x < array.length) { ... }

Lista de permissões — combine vários equals com ||:

if (status.equals("READY") || status.equals("RUNNING") || status.equals("DONE")) { ... }

(Para listas longas, prefira List.of(...).contains(status) ou um switch.)

Cláusulas de guarda — falhe rapidamente com !:

if (!isAuthenticated) {
    throw new AuthException();
}
// ... main logic ...

Leis de De Morgan

Ao negar uma expressão combinada, os operadores são invertidos:

!(a && b)    is the same as    !a || !b
!(a || b)    is the same as    !a && !b

Assim, !(age >= 18 && hasId) é age < 18 || !hasId. A maioria dos leitores prefere a forma positiva quando possível — refatore em direção ao que for mais fácil de ler.

Uma demonstração

java— editable, runs on the server

O que vem a seguir

Java If...Else — onde esses testes boolean são realmente usados para ramificar o seu código.
Java Bitwise Operators — para os raros momentos em que você realmente precisa manipular bits brutos.

Prática

Qual expressão verifica com segurança que user não é null E que user.isActive() retorna true?

user != null && user.isActive()user.isActive() && user != nulluser != null & user.isActive()!(user == null) && user.isActive()