# Java AND OR operators : découvrez comment ils fonctionnent

Les opérateurs logiques Java AND et OR sont utilisés pour vérifier la véracité de deux conditions. Ces deux opérateurs fonctionnent certes de manière très similaire, mais ils se distinguent dans les détails. Découvrez comment fonctionnent les opérateurs OR et AND en langage Java à l’aide de quelques exemples simples.

## Java : AND OR operators

Les opérateurs Java sont des outils importants pour l’utilisation du langage de programmation. Ils peuvent être classés en différentes catégories et remplissent différentes fonctions. Deux outils particulièrement utiles pour apprendre à programmer sont AND et OR en langage Java. Ces deux outils appartiennent au groupe des opérateurs logiques et sont utilisés pour examiner la **véracité d’un état supposé**. Pour cela, ils donnent une **valeur booléenne comme réponse**. Cette valeur est « true » si l’affirmation est correcte, ou « false » si elle est fausse.

L’opérateur AND en langage Java examine deux états et ne donne un `true` que si **les deux affirmations sont vraies**. Si ce n’est pas le cas, il répond par `false`. C’est indiqué par `&&`. L’opérateur OR en Java examine également deux états et donne `true` si **au moins une des deux affirmations est vraie**. Il ne répond par `false` que si les deux affirmations sont fausses. C’est indiqué par `||`.

La syntaxe des deux opérateurs logiques est très similaire et ressemble à ceci :

```java
affirmation1 opérateur affirmation2
```

Découvrez comment utiliser AND et OR en langage Java à l’aide des quelques exemples pratiques ci-dessous.

## AND operator in java : comment fonctionne-t-il ?

L’opérateur AND est utilisé en langage Java pour vérifier si deux affirmations sont vraies. Il est composé comme suit :

```java
affirmation1 && affirmation2
```

Il indique `true` uniquement si les deux conditions sont vraies. Si l’une des deux affirmations est fausse ou si les deux ne s’appliquent pas, il indique `false`.

Dans notre premier exemple, nous donnons au système deux affirmations simples et nous lui indiquons avec la commande Java `System.out.println` d’afficher la valeur booléenne applicable. Cela prend la forme suivante :

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

Le système vérifie d’abord si la valeur 3 est supérieure à 1, ce qui est correct. Il vérifie ensuite si l’affirmation `3 < 7` est correcte. Celle-ci est aussi correcte. Les deux affirmations sont donc correctes et nous obtenons l’indication `true`.

Nous pouvons maintenant observer ce qui se passe lorsqu’une affirmation est vraie mais pas l’autre. Pour ce faire, nous avons légèrement modifié notre exemple :

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

Dans ce cas, le système vérifie également la première affirmation et constate qu’elle est correcte. En revanche, la deuxième affirmation est fausse. Comme les deux conditions doivent être remplies, nous obtenons l’indication `false`.

Dans notre troisième exemple, la vérification est encore plus brève. Étant donné que la première condition n’est pas remplie, le système ne tient plus compte de la deuxième affirmation. La valeur indiquée ne peut être que `false` :

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

## OR operator in Java : comment est-il utilisé ?

L’opérateur OR en Java vérifie aussi deux conditions. Il est composé comme suit :

```java
affirmation1 || affirmation2
```

Contrairement à l’opérateur AND en Java, il est essentiel, pour lui, qu’au moins une des deux conditions soit remplie. Si c’est le cas, il indique `true`. Cette indication est également fournie lorsque les deux conditions sont remplies. Ce n’est que si **aucune des deux conditions n’est remplie** qu’il indiquera `false`. Voici quelques exemples simples permettant d’illustrer cette fonction.

Dans le premier cas, nous remplaçons simplement l’opérateur `&&` du premier exemple par `||`. Cela prend alors la forme suivante :

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

Comme pour l’opérateur AND, l’indication obtenue est `true`. Comme la première affirmation est déjà vraie, la condition est remplie. Les différences entre AND et OR en Java apparaissent cependant clairement dans l’exemple suivant.

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

La première affirmation est vraie, car 3 est effectivement plus grand que 1. En revanche, la deuxième affirmation est fausse, car 3 n’est pas plus grand que 7. Mais étant donné qu’au moins une des deux affirmations est vraie, le système indiquera quand même `true`. La supposition erronée de la deuxième affirmation n’est pas pertinente à cet égard.

Nous obtenons l’indication `false` uniquement si aucune des deux conditions n’est remplie. Pour illustrer ce point, voici l’exemple correspondant :

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

Le système vérifie la première affirmation et constate qu’elle est fausse. Il se tourne donc vers la deuxième affirmation. Si celle-ci était vraie, nous obtiendrions à nouveau l’indication `true`. Cependant, comme les deux affirmations sont fausses, nous obtenons l’indication `false`.


This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/operateurs-java-and-et-or/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/operateurs-java-and-et-or/) for AI/LLM consumption.