Operadores de comparação e operadores lógicos — Java

O que é isso e para que serve?

Imagine que você é um robô que toma decisões. Por exemplo: "Se estiver chovendo lá fora, pegue um guarda-chuva". Ou: "Se eu tenho 100 rublos E quero sorvete, então compro". Na programação, essas decisões são ajudadas por operadores de comparação (eles comparam números ou texto) e operadores lógicos (eles conectam várias condições em uma).

Em Java, como na vida, temos perguntas: "O número 10 é maior que 5?", "As duas palavras são iguais?", "Duas condições são satisfeitas ao mesmo tempo?". As respostas são sempre "sim" (true) ou "não" (false). É como um semáforo: se está verde (true) — andamos, se está vermelho (false) — paramos.

Para que isso é necessário? Sem eles, o computador não consegue decidir sozinho o que fazer em diferentes situações. Por exemplo, em um jogo: se o jogador perdeu todas as vidas (vidas == 0), então mostrar "Game Over". Ou em uma calculadora: se um número maior que 100 for inserido, então exibir um aviso. Operadores de comparação e operadores lógicos são a base de qualquer comportamento "inteligente" de programas.

Em Python, aliás, é tudo muito parecido: também existem ==, !=, >, <, >=, <= e os lógicos and, or, not. Mas em Java há uma diferença importante: strings (texto) são comparadas não com ==, mas com um comando especial .equals(). Vamos abordar isso em detalhes.

Exemplos de código com explicação

Exemplo 1: Comparação de números (simples "maior/menor")

// Declarando variáveis com números
int idadePedro = 12;
int idadeVasco = 14;

// Comparando: a idade de Pedro é maior que a idade de Vasco?
boolean pedroMaisVelho = idadePedro > idadeVasco;
System.out.println("Pedro é mais velho que Vasco? " + pedroMaisVelho); // Exibe: false

// Comparando: a idade de Pedro é menor que a idade de Vasco?
boolean pedroMaisNovo = idadePedro < idadeVasco;
System.out.println("Pedro é mais novo que Vasco? " + pedroMaisNovo); // Exibe: true

// Verificando igualdade
boolean saoDaMesmaIdade = idadePedro == idadeVasco;
System.out.println("Eles têm a mesma idade? " + saoDaMesmaIdade); // Exibe: false

// Verificando desigualdade
boolean idadesDiferentes = idadePedro != idadeVasco;
System.out.println("As idades são diferentes? " + idadesDiferentes); // Exibe: true

Explicação: Criamos duas variáveis com números. O operador > verifica se o primeiro número é maior que o segundo. Se sim — valor true, senão false. O operador < — ao contrário. == verifica igualdade (observe: dois sinais de igual, não um! Um sinal é atribuição). != — verifica se os números não são iguais. O resultado de cada comparação é um valor lógico true ou false, que armazenamos em uma variável do tipo boolean (tipo lógico).

Exemplo 2: Comparação de strings (texto) — diferença importante do Python

String nome1 = "Ana";
String nome2 = "Ana";
String nome3 = "João";

// Comparando strings com equals (não com ==!)
boolean anaEAnaSaoIguais = nome1.equals(nome2);
System.out.println("Nome1 e Nome2 são iguais? " + anaEAnaSaoIguais); // true

boolean anaEJoaoSaoIguais = nome1.equals(nome3);
System.out.println("Nome1 e Nome3 são iguais? " + anaEJoaoSaoIguais); // false

// Comparando sem considerar maiúsculas/minúsculas
String nome4 = "ana";
boolean semConsiderarMaiusculas = nome1.equalsIgnoreCase(nome4);
System.out.println("Ana e ana (sem considerar maiúsculas)? " + semConsiderarMaiusculas); // true

// Isso NÃO deve ser feito (explicaremos nos erros)
boolean comparacaoPerigosa = (nome1 == nome2);
System.out.println("Com ==: " + comparacaoPerigosa); // Pode exibir true, mas é por acaso!

Explicação: Em Java, strings não são números simples, mas objetos complexos. O operador == verifica se as strings estão no mesmo local da memória, e não se o texto é igual. Por isso, para comparar texto, usa-se o método .equals(). Se quiser comparar sem considerar maiúsculas/minúsculas (por exemplo, "Ana" e "ana"), use .equalsIgnoreCase(). Em Python, aliás, para strings pode-se usar == — lá funciona corretamente. Mas em Java — lembre-se: strings só com equals!

Exemplo 3: Operadores lógicos — "E" (&&), "OU" (||), "NÃO" (!)

int temperatura = 25;
boolean estaSol = true;
boolean temVento = false;

// Verificando condição composta: "Sair para passear se estiver quente E sol"
boolean podePassear = (temperatura > 20) && estaSol;
System.out.println("Pode passear? " + podePassear); // true (25 > 20 E sol = true)

// Verificando: "Levar casaco se estiver frio OU ventando"
boolean levarCasaco = (temperatura < 15) || temVento;
System.out.println("Levar casaco? " + levarCasaco); // false (NÃO está frio E NÃO está ventando)

// Usando "NÃO": "Se NÃO estiver chovendo, vamos passear"
boolean estaChovendo = false;
boolean naoEstaChovendo = !estaChovendo; // ! transforma false -> true
System.out.println("Não está chovendo? " + naoEstaChovendo); // true

// Exemplo complexo: "Ficar em casa se estiver frio E (chuva OU vento)"
int temperatura2 = 10;
boolean chuva = true;
boolean vento = false;
boolean ficarEmCasa = (temperatura2 < 15) && (chuva || vento);
System.out.println("Ficar em casa? " + ficarEmCasa); // true (frio E chuva)

Explicação: Operadores lógicos funcionam como na matemática e na vida. && (E) resulta em true apenas se ambas as condições forem true. || (OU) resulta em true se pelo menos uma condição for true. ! (NÃO) inverte o valor: true vira false, false vira true. Em Python é a mesma coisa, só que escrito por extenso: and, or, not. Em Java usam-se símbolos, mas o significado é absolutamente o mesmo. Parênteses ajudam a definir a ordem: primeiro calcula-se o que está dentro dos parênteses, depois o resto.

Exemplo 4: Uso em if-else (decisões reais)

int pontos = 85;
int pontuacaoMinima = 70;

if (pontos >= pontuacaoMinima) {
    System.out.println("Você passou! Parabéns!");
} else {
    System.out.println("Tente novamente.");
}