• 10 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 25/07/2022

Contrôlez le déroulement d'un programme avec des conditions

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 prédéfinie ne sera plus suffisante. C’est là que vous aurez besoin des conditions !

Reprenons le programme Hello World sur lequel nous avions travaillé :

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 précises 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 la prochaine partie). 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 ajouter des  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é  Esther  , une  String  . 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 les booléens.

Vous vous souvenez des booléens ?

boolean isLearningJavaWithOpenclassrooms = true;

Ce qui importe vraiment, c'est que la condition du 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 weatherToday="The weather is good";
String weatherTomorrow="The weather is good";
weatherToday.equals(weatherTomorrow); // -> true

equals  est une méthode de la classe   String  qui permet de comparer deux chaînes.

En effet, on ne compare pas deux objets via  ==  .  ==  vérifie si deux objets ne font qu’un (la même adresse en mémoire), et non s’ils ont le même contenu.  La méthode equals, par opposition, compare le contenu. Elle peut donc être utilisée comme une condition.

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

Utilisez les 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.

Utilisez les 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

Dans notre exemple Hello World, nous avons défini une alternative.

Et si on veut 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  contient 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 if (args.length==3) {
        sayHelloTo(args[0] + "-" + args[1] + "-" + args[2]);
    } else {
        sayHelloTo("world");
    }
}

Dans cet exemple, notre code évalue 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.

Utilisez 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.

Réécrivons notre exemple if, else if et 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 validés en cascade. Pour éviter cela, terminez chaque cas par une instruction   break;  ;

  • la clause Default à la fin est validée si aucun des autres cas n’est validé.

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 énumération

Les énumérations sont des listes 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, en bloquant par exemple les valeurs que peut prendre une variable.

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  .

Voici dans cet exemple l’énumération :

enum Direction {
north, east, south, west;
}

Comme le switch doit couvrir tous les cas possibles, nous pouvons utiliser deux approches.

Approche n°1 : lister tous les cas d'énumération en switch
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 théoriquement pas besoin de la clause   default  .

Approche n°2 : définir un cas d'utilisation en particulier

Définissons le cas d'utilisation où nous ne devrons 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 !

 

https://api.next.tech/api/v1/publishable_key/2A9CAA3419124E3E8C3F5AFCE5306292?content_id=815dcbcd-8ad5-486b-bcf4-a93ed7c3315a

En résumé

  • Les conditions vous permettent d'exécuter un bloc de code uniquement si une valeur   boolean  , une variable ou une expression est évaluée 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.

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