Tutorial: Operadores Java AND e OR

Os operadores lógicos AND e OR em Java são usados para verificar se duas condições são verdadeiras. Esses dois operadores funcionam de maneira muito parecida, mas há detalhes importantes que os diferenciam. Veja exemplos simples explicando como funcionam os operadores AND e OR em Java.

Java AND e OR

Operadores Java são importantes ferramentas para trabalhar com linguagens de programação. Eles podem ser divididos em diversas categorias e cumprem diferentes funções. Dois exemplos muito úteis ao aprender a programar, são os operadores de Java AND e OR. Ambos pertencem ao grupo dos operadores lógicos e são usados para verificar se um determinado estado está correto. Para isso, eles emitem um valor booleano como resposta. Esse valor pode ser “true”, quando o estado for correto, ou “false”, quando ele for incorreto ou não se aplicar. O operador AND em Java verifica dois estados e só retorna “true” quando ambas as afirmativas forem verdadeiras. Caso contrário, ele retorna “false”. Esse operador é expresso pelos sinais “&&” no código. O operador OR, por sua vez, também verifica os dois estados mas retorna “true” contanto que pelo menos uma das duas afirmativas seja verdadeira. Esse operador só retorna “false” quando as duas afirmativas forem falsas e é expresso pelos sinais “||”.

A sintaxe dos dois operadores é muito parecida. Ambos são escritos conforme o modelo abaixo:

afirmativa1 operador afirmativa2

A seguir, alguns exemplos práticos esclarecem como você pode usar os operadores de Java AND e OR.

Operador AND em Java

Em Java, o operador AND é usado para verificar se duas afirmativas são verdadeiras. Ele é escrito da seguinte forma:

afirmativa1 && afirmativa2

Só quando ambas as alternativas forem verdadeiras, o resultado é “true”. Se uma das duas for incorreta ou não se aplicar, a resposta é “false”.

Em nosso primeiro exemplo, fornecemos ao sistema duas afirmativas simples e, para exibir o resultado, utilizamos o comando Java System.out.println que retorna o respectivo valor booleano. Isso é feito da seguinte forma:

public class Main {
	public static void main(String[] args) {
		int x = 3;
		System.out.println(x > 1 && x < 7);
	}
}

O sistema verifica primeiro se o valor 3 é maior do que 1. Isso é correto. Depois, ele verifica se a afirmativa “3 < 7” é correta. Essa segunda afirmativa também é correta. Portanto, ambas as afirmativas são corretas e o código retorna “true”.

Agora vamos ver o que acontece se uma afirmativa for verdadeira e a outra não. Para isso, basta mudar um pouco o exemplo anterior:

public class Main {
	public static void main(String [] args) {
		int x = 3;
		System.out.println(x > 1 && x > 7);
	}
}

Como no exemplo anterior, o sistema verifica a primeira afirmativa e determina que ela está verdadeira. Mas, dessa vez, ao verificar a segunda afirmativa ele determina que ela é falsa. Como a condição é que ambas as afirmativas sejam corretas, o sistema retorna “false”.

Em um terceiro exemplo, a verificação é mais rápida. Como a primeira afirmativa é falsa, o sistema nem precisa mais verificar a segunda afirmativa. Afinal, basta que uma das afirmativas seja falsa para que o resultado seja “false”:

public class Main {
	public static void main(String [] args) {
		int x = 3;
		System.out.println(x > 3 && x < 7);
	}
}

Operador OR em Java

O operador OR em Java também verifica duas condições. Ele é escrito da seguinte forma:

afirmativa1 || afirmativa2

Ao contrário do operador AND, o que é decisivo para o operador OR é que pelo menos uma das afirmativas seja verdadeira. Nesse caso, ele emite “true” como resultado. Essa mesma resposta também é emitida quando ambas as afirmativas são corretas. Só quando nenhuma das duas afirmativas for correta, a resposta será “false”. Alguns exemplos simples abaixo ilustram esse princípio.

Primeiro, vamos só substituir o operador && do primeiro exemplo acima pelo operador ||. O código fica assim:

public class Main {
	public static void main(String [] args) {
		int x = 3;
		System.out.println(x > 1 || x < 7);
	}
}

Assim como com o operador AND, o código retorna “true”. Como a primeira verificação já mostra que a primeira afirmativa é verdadeira, o sistema nem precisa verificar a próxima. A condição de que pelo menos uma das afirmativas seja correta está cumprida. A diferença entre os operadores de Java AND e OR fica ainda mais clara no próximo exemplo.

public class Main {
	public static void main(String [] args) {
		int x = 3;
		System.out.println(x > 1 || x > 7);
	}
}

A primeira afirmativa é correta, pois 3 é maior do que 1. O sistema novamente não verifica a segunda afirmativa, mas ela está errada, pois 3 não é maior do que 7. Como, para o operador OR, pelo menos uma das afirmativas deve ser verdadeira, o sistema retorna “true”. Diferentemente do que ocorre com o operador AND, nesse caso o fato de a segunda afirmativa ser falsa é irrelevante.

A resposta “false” só é emitida quando nenhuma das duas afirmativas é correta. Se esse for o caso, o exemplo fica assim:

public class Main {
	public static void main(String [] args) {
		int x = 3;
		System.out.println(x > 3 || x > 7);
	}
}

O sistema verifica a primeira afirmativa e determina que ela é incorreta. Em seguida, ele verifica a próxima afirmativa. Se ela fosse correta, receberíamos novamente a resposta “true”. Mas, como ambas as afirmativas são falsas, o sistema retorna “false”.