Tutorial: Ope­ra­do­res Java AND e OR

Os ope­ra­do­res lógicos AND e OR em Java são usados para verificar se duas condições são ver­da­dei­ras. Esses dois ope­ra­do­res funcionam de maneira muito parecida, mas há detalhes im­por­tan­tes que os di­fe­ren­ciam. Veja exemplos simples ex­pli­cando como funcionam os ope­ra­do­res AND e OR em Java.

Java AND e OR

Ope­ra­do­res Java são im­por­tan­tes fer­ra­men­tas para trabalhar com lin­gua­gens de pro­gra­ma­ção. Eles podem ser divididos em diversas ca­te­go­rias e cumprem di­fe­ren­tes funções. Dois exemplos muito úteis ao aprender a programar, são os ope­ra­do­res de Java AND e OR. Ambos pertencem ao grupo dos ope­ra­do­res lógicos e são usados para verificar se um de­ter­mi­nado 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 afir­ma­ti­vas forem ver­da­dei­ras. 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 afir­ma­ti­vas seja ver­da­deira. Esse operador só retorna “false” quando as duas afir­ma­ti­vas forem falsas e é expresso pelos sinais “||”.

A sintaxe dos dois ope­ra­do­res é muito parecida. Ambos são escritos conforme o modelo abaixo:

afirmativa1 operador afirmativa2

A seguir, alguns exemplos práticos es­cla­re­cem como você pode usar os ope­ra­do­res de Java AND e OR.

Operador AND em Java

Em Java, o operador AND é usado para verificar se duas afir­ma­ti­vas são ver­da­dei­ras. Ele é escrito da seguinte forma:

afirmativa1 && afirmativa2

Só quando ambas as al­ter­na­ti­vas forem ver­da­dei­ras, o resultado é “true”. Se uma das duas for incorreta ou não se aplicar, a resposta é “false”.

Em nosso primeiro exemplo, for­ne­ce­mos ao sistema duas afir­ma­ti­vas simples e, para exibir o resultado, uti­li­za­mos o comando Java System.out.println que retorna o res­pec­tivo 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 afir­ma­tiva “3 < 7” é correta. Essa segunda afir­ma­tiva também é correta. Portanto, ambas as afir­ma­ti­vas são corretas e o código retorna “true”.

Agora vamos ver o que acontece se uma afir­ma­tiva for ver­da­deira 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 afir­ma­tiva e determina que ela está ver­da­deira. Mas, dessa vez, ao verificar a segunda afir­ma­tiva ele determina que ela é falsa. Como a condição é que ambas as afir­ma­ti­vas sejam corretas, o sistema retorna “false”.

Em um terceiro exemplo, a ve­ri­fi­ca­ção é mais rápida. Como a primeira afir­ma­tiva é falsa, o sistema nem precisa mais verificar a segunda afir­ma­tiva. Afinal, basta que uma das afir­ma­ti­vas 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 afir­ma­ti­vas seja ver­da­deira. Nesse caso, ele emite “true” como resultado. Essa mesma resposta também é emitida quando ambas as afir­ma­ti­vas são corretas. Só quando nenhuma das duas afir­ma­ti­vas for correta, a resposta será “false”. Alguns exemplos simples abaixo ilustram esse princípio.

Primeiro, vamos só subs­ti­tuir 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 ve­ri­fi­ca­ção já mostra que a primeira afir­ma­tiva é ver­da­deira, o sistema nem precisa verificar a próxima. A condição de que pelo menos uma das afir­ma­ti­vas seja correta está cumprida. A diferença entre os ope­ra­do­res 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 afir­ma­tiva é correta, pois 3 é maior do que 1. O sistema novamente não verifica a segunda afir­ma­tiva, mas ela está errada, pois 3 não é maior do que 7. Como, para o operador OR, pelo menos uma das afir­ma­ti­vas deve ser ver­da­deira, o sistema retorna “true”. Di­fe­ren­te­mente do que ocorre com o operador AND, nesse caso o fato de a segunda afir­ma­tiva ser falsa é ir­re­le­vante.

A resposta “false” só é emitida quando nenhuma das duas afir­ma­ti­vas é 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 afir­ma­tiva e determina que ela é incorreta. Em seguida, ele verifica a próxima afir­ma­tiva. Se ela fosse correta, re­ce­be­ría­mos novamente a resposta “true”. Mas, como ambas as afir­ma­ti­vas são falsas, o sistema retorna “false”.