Les Conditions
Published: 2021-05-31 12:07:17

---
title: Les Conditions
published: true
description: 
tags: 
cover_image: https://cdn.journaldev.com/wp-content/uploads/2017/10/java-do-while-loop-1.png
---


Nous prenons sans arrêt des décisions dans la vie : Si tu prend cette voiture, je ferais ceci ; sinon, je ferai autre chose. Java possède une clause qui évalue une expression donnée pour savoir si sa valeur est true ou false.
Selon la valeur de cette expression, l'exécution de votre programme prend une direction ou une autre ; seule la portion de code correspondante est exécutée.
Si l'expression retourne true, Java exécute le code compris entre les deux premières accolades, sinon, il va directement au code suivant la clause else. 

Par exemple, si un visiteur a un température supérieur à 37 degrés il sera refusé l’accès au magasin sinon il sera autorisé à entrer dans le magasin.
```java
// Tester qui va rentrer dans le magasin suivant sa température
if (temperature > 37) {
    System.out.println("Tu as trop de fièvre. Va faire un test covid");
   }
else {
       System.out.println("Tu peux rentrer dans le magasin");
   }
```
Parfois, pour prendre une décision, il peut être nécessaire de vérifier plus d'une expression conditionnelle. 

Par exemple, si la marque de voiture est "Renault" ou "Peugeot", ne pas ajouter de taxe d'Etat au prix du voiture. C'est un cas d'emploi du **ou logique**. 
En Java, un **ou logique** est représenté par une ou deux barres verticales (**|** ou **||**) . Ca fonctionne comme ceci : si l'une quelconque des conditions est vraie, le résultat de l'expression dans son ensemble vaut true.
```java
if (marque.equals("Renault") | marque.equals("Peugeot"))
```
Tu peux aussi écrire ceci en utilisant deux barres verticales :
```java
if (marque.equals("Renault") || marque.equals("Peugeot"))
```

Le **et logique** (logical and) est représenté par un ou deux "et commercial" (**&&**) et l'expression dans son ensemble vaut true si
chacune de ses parties vaut true. 
Par exemple, imputer les taxes
commerciales uniquement dans le cas où la marque est "Ford" et où le
prix est supérieur à 12500. Les deux conditions doivent être vraies en
même temps :
```java
if (marque.equals("Ford") && prix > 12500)
```
ou
```java
if (marque.equals("Ford") & prix > 12500)
```

Le **non logique** (logical not) est représenté par le point d'exclamation et donne à l'expression le sens opposé. Par exemple, si tu veux effectuer certaines actions uniquement si la marque n'est pas "Mercedes", utilise cette syntaxe :
```java
if (!marque.equals("Mercedes")){
//
}
```
Voici un autre exemple: les deux expressions suivantes produiront le même résultat :
```java
if (prix < 12500){
//
}
```
```java
if (!(prix >= 12500)){
//
}
```
Le **non logique** est ici appliqué à l'expression entre parenthèses.

####Opérateur ternaire
Il existe une autre forme de la clause if : l'opérateur conditionnel ou opération ternaire. On l'utilise pour affecter une valeur à une variable en fonction d'une expression terminée par un point d'interrogation. Si l'expression est vraie, la valeur suivant le point d'interrogation est utilisée ; sinon, la valeur suivant les deux points est affectée à la variable située à gauche du signe égal. 

```java
String name = "WERNER"; // Le nom d'un joueur
String playerName = name.equals("WERNER") ? " Not Found" : name ;
System.out.println("Player is : "+playerName);
```
L'opérateur ternaire Java fonctionne comme une instruction if Java simplifiée
```java
remise = prix > 50 ? 10 : 5;
```
Si le prix est supérieur à 50, la variable remise prend la valeur 10 ;
sinon, elle vaut 5. C'est juste un raccourci pour exprimer une clause if normale :
```java
if (prix > 50) {
   remise = 10;
}
else {
   remise = 5;
}
```

Tu peux construire des clauses if plus complexes avec plusieurs blocs else if
```java
if (noteDevoir >= 18) {
   niveau = 'E';
}
else if (noteDevoir >= 16 && noteDevoir < 18) {
   niveau = 'T';
}
else if (noteDevoir >= 14 && noteDevoir < 16) {
   niveau = 'B';
}
else if (noteDevoir >= 12 && noteDevoir < 14) {
   niveau = 'A';
}
else if (noteDevoir >= 10 && noteDevoir < 12) {
   niveau = 'P';
}
else {
   niveau = 'I';
}
```


La **clause switch** peut parfois être utilisée comme alternative à if.
L'expression après le mot-clé **switch** est évaluée et le programme va directement au **case** (cas) correspondant

```java
switch (tonNiveau) {
   case 'E':
       System.out.println("Excellent travail !");
       break;
   case 'T':
       System.out.println("Très bon travail !");
       break;
   case 'B':
       System.out.println("Bon travail !");
       break;
   case 'A':
       System.out.println("Tu peux mieux faire !");
       break;
   case 'P':
       System.out.println("Tu dois travailler plus !");
       break;
   case 'I':
       System.out.println("Change d'attitude !");
       break;
}
```

prochain chapitre: [Les instructions répétitives avec For
](https://dev.to/tonux_samb/les-instructions-repetitives-avec-for-3jlj)