• 15 heures
  • Facile

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 19/05/2021

Sélectionnez la condition appropriée pour contrôler le déroulement de votre programme

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Au fur et à mesure que vous allez écrire des programmes de plus en plus sophistiqués, l'écriture de lignes de code qui doivent s'exécuter l'une après l'autre selon une séquence définie ne sera plus suffisante. C'est là que le déroulement du programme entre en jeu.

Reprenons le programme Hello World sur lequel nous avions travaillé dans le chapitre 4 de la partie 1 :

package hello;
/** Ceci est une implémentation du message traditionnel "Hello world!"
* @author L'équipe Education d'OpenClassrooms
*/
public class HelloWorld {
/** Le programme commence ici */
public static void main(String[] args) {
System.out.println("Hello World!");
}
}

Nous avons dit bonjour au monde entier. Ne serait-il pas agréable d'être un peu plus précis, par exemple dire bonjour à une personne réelle ? 🙋🏽🙋🙋🏻♂‍

Affichez des informations plus spécifiques si elles sont disponibles

Au démarrage du programme, il se peut que vous ne connaissiez pas le nom d'un utilisateur. Alors pourquoi ne pas utiliser quelque chose comme :

  • if (si) nous connaissons le nom de la personne, l'afficher ;

  • else (sinon), continuer à dire bonjour au monde entier.

Voilà à quoi servent les conditions.

Comment pouvons-nous donc connaître le nom de cette personne ?

Revenons à la toute première déclaration qu'un programme exécute, la signature de la fonction main :

public static void main(String[] args) {

Avez-vous remarqué  String[] args  à l'intérieur des parenthèses   ()  ? Nous avons une variable  args  définie avec le type  String[], qui est un tableau de chaînes de caractères (nous y reviendrons dans le prochain chapitre). Cela signifie que la fonction main est capable de recevoir des arguments que nous pouvons utiliser lorsque le programme est lancé.

Vous vous souvenez de la commande qui démarre un programme Java depuis le terminal ? Si on reprend notre exemple Hello World, nous avions suivi les étapes suivantes :

  1. Compiler le programme avec la commande javac.

  2. Exécuter le programme avec la commande java.

La magie qui consiste à envoyer les arguments à votre programme se déroule durant la deuxième phase. Au lieu de simplement fournir le nom de la classe contenant la méthode main, vous pouvez fournir d'autres arguments, séparés par un espace. Voici ce que vous pouvez faire :

$ java hello.HelloWorld Esther

Après le nom de la classe, nous avons ajouté la chaîne Esther. Au démarrage du programme, cette chaîne est contenue dans le tableau  args  qui fait partie de la signature de la fonction principale. Cependant, notre code original ne s'en sert pas. Nous devons le changer pour :

  1. Vérifier si le tableau  args  contient une valeur (la propriété  length  fournie par les tableaux peut nous aider ici).

  2. Si c'est le cas, appeler la méthode  sayhelloTo  avec la valeur qu'elle contient.

  3. Sinon, continuer à appeler la méthode avec la chaîne  world.

Voilà ce que ça donne :

package conditions;
/**Ce programme affiche
* - un message Hello personnalisé si un argument a été envoyé lors de l'exécution du programme
* - le message traditionnel "Hello World!" si ce n'est pas le cas
* @author L'équipe éducation d'OpenClassrooms
*/
public class ConditionalHello {
/** Le programme commence ici
* @param args arguments envoyé avec la ligne de commande
*/
public static void main(String[] args) {
if (args.length==1) {
sayHelloTo(args[0]);
}
else {
sayHelloTo("world");
}
}
/** affiche le message hello au destinataire fourni
* @param recipient
*/
private static void sayHelloTo(String recipient) {
System.out.println("Hello " + recipient + "!");
}
}

Maintenant :

1. Compilez le programme avec la commande javac.

$ javac conditions/ConditionalHello.java

2. Exécutez le programme sans argument.

$ java conditions/ConditionalHello 
Hello world! 
$

3. Exécutez le programme en ajoutant "Esther" après le nom de la classe.

$java conditions/ConditionalHello Esther
Hello Esther!
$

Ça marche ! Voyons plus en détail comment fonctionne réellement cette affectation conditionnelle If/Else.

Testez vos conditions avec des booléens

En langage Java, pour valider une condition, vous utilisez un type de données spécial appelé  boolean  . Une variable de type booléen ne peut contenir que deux valeurs : true ou false. Un  boolean  est le type de données le plus simple.

En Java, les types  boolean  utilisent des paires vrai/faux (true/false). Pour déclarer une variable booléenne, spécifiez son type comme  boolean  . Déclarons quelques variables booléennes :

boolean theCourseIsExcellent = true;
boolean theAuthorIsHumble = false;

C'est logique, n'est-ce pas ? 😉

Ce qui importe vraiment, c'est que la condition qui est exprimée à l'intérieur des parenthèses et après le mot clé  if  soit résolue par un booléen. Cette condition peut être exprimée de la façon suivante :

  1. Une valeur true ou false. Par exemple,  if(true).

  2. Une variable de type  boolean . Par exemple,  if(myVar)  où  myVar  est de type  boolean .

  3. Une expression qui se résout en une valeur booléenne. Cette expression peut être aussi simple que le résultat d'un appel de méthode.

Par exemple :

String weather="The weather is good";
weather.startsWith("The weather"); // -> true

startsWith  est une méthode de la classe  String  qui retourne  true  si cette chaîne commence par le préfixe spécifié. Elle peut donc être utilisée comme une condition.

Pour produire un booléen, vous pouvez également utiliser des opérateurs de comparaison.

Opérateurs de comparaison

Comme leur nom l'indique, les opérateurs de comparaison sont utilisés pour comparer deux valeurs. Ils sont au nombre de six :

  • ==  égal à (exactement le même) ;

  • !=  non égal à (différent, de quelque façon que ce soit) ;

  • <  inférieur à ;

  • <=  inférieur ou égal à ;

  • >  supérieur à ;

  • >=  supérieur ou égal à.

Voici quelques exemples de comparaisons numériques :

2 == 2 // -> true
2 == 3 // -> false
4 != 4 // -> false
4 != 5 // -> true
1 < 2 // -> true
1 < 1 // -> false
1 <= 1 // -> true
3 > 4 // -> false
5 > 4 // -> true
5 >= 4 // -> true

Enfin, vous voudrez peut-être avoir des conditions plus compliquées, où la décision dépend du résultat d'une combinaison d'expressions différentes. C'est ici que vous utiliserez les opérateurs logiques.

Opérateurs logiques

Ces opérateurs vous permettent de combiner des valeurs booléennes : soit des valeurs booléennes spécifiques, soit des résultats d'expressions. Ils sont au nombre de trois :

  • &&  ET logique.
    Le résultat n'est vrai que si toutes les parties participantes sont vraies. 
    Exemple : le résultat de  expression1 && expression2  n'est vrai que si  expression1  est vraie ET  expression2  est également vraie.

  • ||  OU logique.
    Le résultat est vrai si au moins une des parties participantes est vraie. 
    Exemple : le résultat de  expression1 || expression2  est vrai si  expression1  est vraie OU  expression2  est vraie. Il en sera de même si les deux expressions sont vraies !

  • !  NON logique.
    Il inverse simplement l'expression donnée.
    Le résultat de  !expression1  est vrai si  expression1  est fausse ; le résultat est faux si  expression1  est vraie.

Voici quelques exemples :

true && true // -> true
true && false // -> false
false && false // -> false
true || false // -> true
true || true // -> true
false || false // -> false
!true // -> false
!false // -> true

Les mêmes règles s'appliquent si plus de deux expressions sont enchaînées les unes après les autres :

true && true && true // -> true
true && true && false // -> false
true || false || false// -> true
false || false || false// -> false

Comme pour les opérateurs numériques, les opérateurs logiques respectent la priorité des opérations : l'opérateur d'inversion  !  vient en premier, puis l'opérateur ET  &&  et enfin, l'opérateur OU ||. Par exemple :

false || true && true // -> true
!false && true || false // -> true

Comme pour les opérateurs numériques, utilisez les parenthèses (() ) pour changer l'ordre :

(true && false) || true // -> true
!(true && false || !true) // -> true

Pour vous entraîner, pouvez-vous calculer le résultat des expressions suivantes ?

!true && false
!(true && false)
4 < 3 || 4 >= 4
(!(1 == 2) || 3 != 3) && 35 > 34

En résumé : la forme générale d'une instruction conditionnelle en Java est  if(condition)  : la condition est soit une valeur booléenne, soit une variable de type  boolean , soit le résultat de toute expression qui produit une valeur booléenne.

Dans notre exemple Hello World, nous avons défini une alternative. Et si vous voulez prendre des décisions plus complexes, basées sur plusieurs valeurs possibles ?

Gérez une chaîne de conditions

Nous avons personnalisé notre message de bienvenue, mais que faire si nous voulons plaire aux personnes ayant plus d'un prénom ?

Une première possibilité consiste à créer une chaîne de conditions. Voici la forme générale :

if(condition1) {
// instructions
}
else if(condition2) {
// instructions
}
else {
// instructions
}

Dans notre exemple Hello World, nous pourrions envoyer deux chaînes de caractères après le nom de la classe lors de l'exécution du programme. Cela signifierait que le tableau  args  contiendrait deux éléments. Nous pourrions alors envoyer une chaîne contenant la concaténation de ces deux chaînes à notre fonction  sayHelloTo  :

public static void main(String[] args) {
if (args.length==1) {
sayHelloTo(args[0]);
} else if (args.length==2) {
sayHelloTo(args[0] + "-" + args[1]);
} else {
sayHelloTo("world");
}
}

Dans cet exemple, ce que fait réellement notre chaîne est d'évaluer les différentes valeurs d'une condition particulière (la taille du tableau  args). Dans ce cas, Java fournit une construction spécifique qui ne fait l'évaluation qu'une seule fois : l'instruction switch.

L'instruction Switch

Parfois, il y a des circonstances où vous avez un ensemble plus long de conditions à remplir, et où l'une d'elles peut être true dans la séquence. Dans ce cas, une technique, switch, s'avère plus pratique à utiliser. Switch utilise ce qu'on appelle des cas pour comparer une valeur et décider si un bloc de code associé doit être exécuté. Réécrivons notre exemple if/else if/else en utilisant l’instruction switch :

public static void main(String[] args) {
switch(args.length) {
case 0: // aucun argument n'a été envoyé
sayHelloTo("world");
break;
case 1: // l'utilisateur a fourni un argument dans le terminal
sayHelloTo(args[0]);
break;
case 2: // l'utilisateur a fourni 2 arguments
sayHelloTo(args[0] + "-" + args[1]);
break;
default: // l'utilisateur a fourni plus d'arguments qu'on peut en gérer !
System.out.println("Sorry, I don't know how to manage more than 2 names!");
}
}

Avec l'instruction switch :

  • l'expression conditionnelle  args.length  n'est évaluée qu'une seule fois ;

  • chaque cas compare le résultat de l'expression à une valeur spécifique ;

  • par défaut, une fois qu'un cas est évalué true, tous les cas ci-dessous sont également évalués en cascade. Pour éviter cela, terminez chaque cas par une instruction  break; ;

  • la clause Default à la fin traite de tous les cas où le résultat de l'expression ne correspond à aucun cas.

L'instruction switch rend votre intention plus claire qu'une chaîne de if/else et vous permet d'évaluer l'état une seule fois. C'est cool. 😎 Mais ce n'est pas fini ! Encore un autre type de données : les énumérations

Utilisez le type d'énumération

Les énumérations sont une liste de cas prédéfinis destinés à vous aider pendant le développement. Elles améliorent la lisibilité du code et diminuent les risques d'erreurs. Prenons un exemple où nous définissons toutes les directions possibles (nord, est, sud, ouest) dans une énumération et utilisons-les dans un switch. Comme le switch doit couvrir tous les cas possibles, nous pouvons utiliser deux approches.

La première est de lister tous les cas d'énumération en switch, afin que nous n'ayons pas à utiliser l'instruction  default ;

public class myDirection {
/** listez toutes les directions possibles */
enum Direction {
north, east, south, west;
}
/** trouvez le nord */
public static void main(String[] args) {
Direction direction = Direction.north;
switch (direction) {
case north:
System.out.println("You are heading north");
break;
case east:
System.out.println("You are heading east");
break;
case south:
System.out.println("You are heading south");
break;
case west:
System.out.println("You are heading west");
break;
}
}
}

Dans ce cas, nous couvrons toutes les directions, nous n'avons donc pas besoin de la clause  default.

Nous pouvons également définir un cas d'utilisation où nous ne devrions nous diriger que vers le nord :

public static void main(String[] args) {
Direction direction = Direction.north;
switch (direction) {
case north:
System.out.println("You are heading north");
break;
default:
System.out.println("You are lost!");
}
}

À vous de jouer !

Console de code
Houston... ?
Il semblerait que votre ordinateur ne soit pas connecté à Internet.
Vous n'êtes pas connecté

Connectez-vous pour accéder aux exercices de codes et testez vos nouvelles compétences.

Pensez à vous entraîner avant de terminer ce chapitre.

En résumé

  • Les conditions vous permettent d'exécuter un bloc de code uniquement si une valeur  boolean, une variable ou une expression évalue comme  true.

  • Un moyen de fournir des valeurs à un programme est d'envoyer des arguments sur la ligne de commande. Ces arguments sont mis à la disposition de la fonction main dans le tableau  args.

  • Les expressions conditionnelles utilisent l'arithmétique booléenne, notamment les opérateurs de comparaison et les opérateurs logiques.

  • Vous pouvez évaluer plusieurs conditions en créant des chaînes d'instructions if/else if/else.

  • L'instruction switch est une façon plus propre d'exécuter en fonction des différentes valeurs possibles d'une condition particulière.

  • Les énumérations vous permettent de définir un ensemble de valeurs possibles pour rendre votre code encore plus propre.

Découvrez dans le prochain chapitre comment gérer un grand nombre de données avec les tableaux, les listes et les dictionnaires !

Exemple de certificat de réussite
Exemple de certificat de réussite