# Como funcionam os operadores Java AND e OR

Os operadores lógicos AND e OR do Java são utilizados para verificar a correção de duas condições. Embora ambas as funções funcionem de forma muito semelhante, diferem nos detalhes. Explicamos como funcionam estes operadores através de alguns exemplos simples.

## Operadores Java AND e OR

Os operadores Java são uma ferramenta importante ao trabalhar com esta linguagem de programação. Podem ser divididos em diferentes categorias e realizar diferentes tarefas. Duas ferramentas especialmente úteis para aprender a programar são os operadores AND e OR. Ambos pertencem ao grupo dos operadores lógicos e são utilizados 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 verdadeiros**. 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 afirmações for verdadeira**. Só se ambas as afirmações forem falsas é que responde com «false». É indicado com «||».

A sintaxe de ambos os operadores é muito semelhante e tem o seguinte aspecto:

```java
afirmación1 operator afirmación2
```

A seguir, explicamos 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 afirmações são verdadeiras. É formado da seguinte forma:

```java
afirmación1 && afirmación2
```

Responda “true” apenas se ambas as condições forem verdadeiras. Se uma ou ambas as afirmações forem falsas, responda “false”.

No nosso primeiro exemplo, fornecemos ao sistema duas instruções simples e ordenamos que ele mostre o valor booleano apropriado usando o comando Java `System.out.printIn`. O resultado é o seguinte:

```java
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 &lt; 7” está correta, o que também é o caso. Portanto, ambas as afirmações estão corretas e o nosso resultado é “true”.

Agora podemos ver o que acontece se uma afirmação for verdadeira, mas a outra não. Para isso, alteramos ligeiramente o nosso exemplo:

```java
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 satisfeitas, o resultado é «falso».

No nosso terceiro exemplo, a verificação é ainda mais breve. Como a primeira condição não é satisfeita, o sistema já não considera a segunda especificação. Afinal, o valor só pode ser «false»:

```java
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é-requisitos. Ele é formado da seguinte maneira:

```java
afirmación1 || afirmación2
```

Ao contrário do operador AND do Java, para o OR é fundamental que pelo menos uma das duas condições seja satisfeita. Neste caso, o resultado é «true». Este resultado também aparece se ambas as condições forem satisfeitas. Apenas se **nenhuma das duas condições for satisfeita** é que o resultado será «false». Vamos ilustrar novamente com alguns exemplos simples.

No primeiro caso, simplesmente substituímos o operador `&&` do primeiro exemplo por `||`. O resultado é o seguinte:

```java
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á é verdadeira, o pré-requisito é cumprido. No entanto, as diferenças entre AND e OR em Java ficam mais claras no exemplo seguinte:

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

A primeira afirmação é verdadeira, pois 3 é realmente maior que 1. No entanto, a segunda afirmação não é verdadeira, pois 3 não é maior que 7. Contudo, como pelo menos uma das duas afirmações é verdadeira, o sistema continuará a dar como resultado «verdadeiro». A afirmação falsa na segunda afirmação não é relevante para isso.

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

```java
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 verdadeira, receberíamos novamente o resultado «true». No entanto, como ambas as afirmações são falsas, recebemos o resultado «false».


This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/operadores-java-and-e-or/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/operadores-java-and-e-or/) for AI/LLM consumption.