Operadores lógicos

"Olá, amigo!"

"Agora teremos uma pequena aula sobre operadores lógicos."

"Que operadores lógicos você conhece?"

— OU (||), E (&&), NÃO (!)

"Sim. Bom trabalho. E você se lembra de como eles funcionam?"

"Sim."

"OU retorna verdadeiro quando pelo menos um operando é verdadeiro."

"AND retorna verdadeiro quando ambos os operandos são verdadeiros."

"NÃO muda verdadeiro para falso e falso para verdadeiro."

"Isso mesmo. E em que ordem os operadores são avaliados nessa expressão?"

boolean a = true;
boolean b = false;
boolean c = true;

boolean result = a && b || !c && b || !a;

"Isso tudo é muito simples."

"Primeiro, NÃO (!), depois E (&&) e depois OU (||) bem no final."

Se adicionarmos parênteses, obteremos:

boolean a = true;
boolean b = false;
boolean c = true;

boolean result = (a && b) || ((!c) && b) || (!a);

"Está tudo correto, muito bem. E qual é o resultado?"

— 1) (a && b) == (verdadeiro && falso) == falso

2) ((!c) && b) == (falso && falso) == falso

3) (!a) == falso

4) falso || falso || falso == falso

"O resultado é falso."

"Parece que você conhece o assunto perfeitamente. Então vou lhe contar alguns segredinhos."

"Primeiro, as expressões lógicas são avaliadas da esquerda para a direita."

"Em segundo lugar, a avaliação de curto-circuito é usada aqui (os cálculos são executados apenas se necessário). Se o resultado final já for conhecido da avaliação de parte da expressão, o restante da expressão não será avaliado."

boolean result = (true && false) || (true && true) || (true && false);

"Esta expressão é dividida em três partes separadas pelo operador OR (||)."

"Se pelo menos uma parte for verdadeira, então a resposta é verdadeira e nada mais precisa ser considerado. Assim, a expressão é avaliada assim:"

1)  Avalie a primeira parte:  (true && false) == false

2)  Avalie a segunda parte:  (true && true) == true

3) Não avaliamos a terceira parte, pois já está claro que a resposta será verdadeira .

"Essa abordagem também é chamada de avaliação preguiçosa."

"OK. E o que há de tão especial nisso?"

"Nada — até você começar a chamar métodos dentro da expressão. Se parte da expressão for ignorada, os métodos na parte ignorada não serão chamados."

"Mas essa abordagem se tornou muito comum. Veja o porquê:"

Job job = null;

if (job != null && job.isDone())
{
…
}

"Se job for nulo quando a expressão for avaliada, a chamada job.isDone() não acontecerá!"

"De fato, a primeira parte da expressão é falsa, que é seguida por AND (&&). Portanto, toda a expressão será conhecida como falsa e a segunda parte não será necessária."

"Exatamente. É uma boa técnica, certo?"

"Sim."