Como funcionam os ope­ra­do­res Java AND e OR

Os ope­ra­do­res lógicos AND e OR do Java são uti­li­za­dos para verificar a correção de duas condições. Embora ambas as funções funcionem de forma muito se­me­lhante, diferem nos detalhes. Ex­pli­ca­mos como funcionam estes ope­ra­do­res através de alguns exemplos simples.

Ope­ra­do­res Java AND e OR

Os ope­ra­do­res Java são uma fer­ra­menta im­por­tante ao trabalhar com esta linguagem de pro­gra­ma­ção. Podem ser divididos em di­fe­ren­tes ca­te­go­rias e realizar di­fe­ren­tes tarefas. Duas fer­ra­men­tas es­pe­ci­al­mente úteis para aprender a programar são os ope­ra­do­res AND e OR. Ambos pertencem ao grupo dos ope­ra­do­res lógicos e são uti­li­za­dos para analisar a correção de um estado suposto. Para isso, emitem um valor booleano como resposta. Este é «true» se a afirmação estiver correta, ou «false» se não estiver.

O operador AND em Java analisa dois estados e só retorna «true» se ambos os estados forem ver­da­dei­ros. Caso contrário, responde com «false». É expresso com «&&». O operador OR em Java também analisa dois estados e retorna «true» se pelo menos uma das duas afir­ma­ções for ver­da­deira. Só se ambas as afir­ma­ções forem falsas é que responde com «false». É indicado com «||».

A sintaxe de ambos os ope­ra­do­res é muito se­me­lhante e tem o seguinte aspecto:

afirmación1 operator afirmación2

A seguir, ex­pli­ca­mos como usar AND e OR através de alguns exemplos práticos.

Operador AND em Java

O operador AND é utilizado em Java para verificar se duas afir­ma­ções são ver­da­dei­ras. É formado da seguinte forma:

afirmación1 && afirmación2

Responda “true” apenas se ambas as condições forem ver­da­dei­ras. Se uma ou ambas as afir­ma­ções forem falsas, responda “false”.

No nosso primeiro exemplo, for­ne­ce­mos ao sistema duas ins­tru­ções simples e ordenamos que ele mostre o valor booleano apro­pri­ado usando o comando Java System.out.printIn. O resultado é o seguinte:

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 que 1, o que está correto. Em seguida, verifica se a afirmação “3 < 7” está correta, o que também é o caso. Portanto, ambas as afir­ma­ções estão corretas e o nosso resultado é “true”.

Agora podemos ver o que acontece se uma afirmação for ver­da­deira, mas a outra não. Para isso, alteramos li­gei­ra­mente o nosso exemplo:

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

Também neste caso, o sistema verifica a primeira afirmação e determina que ela está correta. No entanto, a segunda afirmação não está correta. Como ambas as condições devem ser sa­tis­fei­tas, o resultado é «falso».

No nosso terceiro exemplo, a ve­ri­fi­ca­ção é ainda mais breve. Como a primeira condição não é sa­tis­feita, o sistema já não considera a segunda es­pe­ci­fi­ca­ção. Afinal, o valor só pode ser «false»:

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

O operador OR em Java

O operador OR em Java também verifica dois pré-re­qui­si­tos. Ele é formado da seguinte maneira:

afirmación1 || afirmación2

Ao contrário do operador AND do Java, para o OR é fun­da­men­tal que pelo menos uma das duas condições seja sa­tis­feita. Neste caso, o resultado é «true». Este resultado também aparece se ambas as condições forem sa­tis­fei­tas. Apenas se nenhuma das duas condições for sa­tis­feita é que o resultado será «false». Vamos ilustrar novamente com alguns exemplos simples.

No primeiro caso, sim­ples­mente subs­ti­tuí­mos o operador && do primeiro exemplo por ||. O resultado é o seguinte:

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

Tal como acontece com o operador AND, agora o resultado é «true». Como a primeira afirmação já é ver­da­deira, o pré-requisito é cumprido. No entanto, as di­fe­ren­ças entre AND e OR em Java ficam mais claras no exemplo seguinte:

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

A primeira afirmação é ver­da­deira, pois 3 é realmente maior que 1. No entanto, a segunda afirmação não é ver­da­deira, pois 3 não é maior que 7. Contudo, como pelo menos uma das duas afir­ma­ções é ver­da­deira, o sistema con­ti­nu­ará a dar como resultado «ver­da­deiro». A afirmação falsa na segunda afirmação não é relevante para isso.

Só re­ce­be­re­mos a resposta «false» se nenhuma das duas condições for cumprida. Vemos isso no exemplo seguinte:

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

O sistema verifica a primeira afirmação e percebe que ela está incorreta. Portanto, ele passa para a segunda afirmação. Se esta fosse ver­da­deira, re­ce­be­ría­mos novamente o resultado «true». No entanto, como ambas as afir­ma­ções são falsas, recebemos o resultado «false». 009f0bf51a40673568185fab79b66230