Precedência de operadores e parênteses em condições

1. Introdução

Vamos começar com uma analogia do dia a dia. Imagine uma receita:

Misture a farinha, os ovos e o açúcar, bata, acrescente a manteiga, bata novamente.

Parece estranho? Agora imagine que entre as palavras “bata” e “adicione” há uma vírgula ou parênteses. A ordem das ações fica imediatamente mais clara.

Em programação, algo parecido acontece quando você escreve uma expressão complexa:

boolean result = a > 0 && b < 10 || c == 3;

Qual é a ordem? O que é avaliado primeiro: a > 0 && b < 10, depois || c == 3? Ou é o contrário?
Sem uma ordem de avaliação clara, o computador pode “trocar os ingredientes”, e o seu resultado será inesperado.

2. Precedência dos operadores em Java

Java (como a maioria das linguagens de programação) usa uma tabela de precedência de operadores.
Operadores com precedência mais alta são avaliados antes dos de precedência mais baixa.

Veja a parte mais importante dessa tabela (para expressões condicionais):

()

!

==, !=

<, >, <=, >=

&&

||

(Existem também operadores aritméticos — eles têm precedência acima dos lógicos.)

Regra principal

Os operadores “E” (&&) têm precedência maior do que “OU” (||),
ou seja, primeiro será avaliado o “E”, depois o “OU”. Não por acaso, E é a multiplicação lógica, e OU é a soma lógica.

Fluxograma de avaliação da precedência das condições

graph LR
    A["a > 0"] --&&--> B["b < 10"]
    B --||--> C["c == 3"]

(Na prática: a > 0 && b < 10 || c == 3 — primeiro calcula‑se a > 0 && b < 10, depois o resultado é combinado com c == 3 por meio de ||.)

3. Direção dos operadores: da esquerda para a direita e vice-versa

Além da precedência, há outro conceito: associatividade.
É a regra que define em que direção os operadores são avaliados quando estão “lado a lado” e têm a mesma precedência.

Exemplo:

boolean a = true, b = false, c = true;
boolean result = a && b && c;

Pergunta: como será avaliado?
Resposta: a associatividade de && é da esquerda para a direita.
Portanto, primeiro a && b, depois o resultado com c.

Aplicado às condições:

&&, ||

!

4. Parênteses — seu melhor aliado em condições complexas

É aqui que começa a mágica (e a salvação). Ao escrever uma expressão, os parênteses alteram a precedência e tornam seu código mais claro e seguro.

Exemplo 1 (sem parênteses):

// Queremos: "Se o usuário for adulto e cidadão, ou se ele tiver um passe especial"
boolean isAdult = age >= 18;
boolean isCitizen = country.equals("Bielorrússia");
boolean hasPermit = hasSpecialPass == true;

if (isAdult && isCitizen || hasPermit)
{
    System.out.println("Acesso permitido!");
}

Como o Java avalia:
Primeiro calcula isAdult && isCitizen, depois combina o resultado com hasPermit usando ||.

• Suponha que isAdult = true, isCitizen = false, hasPermit = true
• isAdult && isCitizen → true && false → false
• false || true → true

Ou seja, se a pessoa tiver um passe especial, ela será autorizada.
E, se não tiver o passe, mas for um cidadão adulto — também será autorizada.

Exemplo 2 (com parênteses):

if (isAdult && (isCitizen || hasPermit))
{
    System.out.println("Acesso permitido!");
}

Agora o programa primeiro verifica: isCitizen || hasPermit, e depois combina esse resultado com isAdult.

Ou seja, é preciso ser adulto e (ou ser cidadão, ou ter um passe especial).
Uma pequena diferença nos parênteses — uma enorme diferença na lógica!