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 :
Compiler le programme avec la commande javac.
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 EstherAprè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 :
Vérifier si le tableau
argscontient une valeur (la propriétélengthfournie par les tableaux peut nous aider ici).Si c'est le cas, appeler la méthode
sayhelloToavec la valeur qu'elle contient.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 :
Compilez le programme avec la commande javac.
$ javac conditions/ConditionalHello.javaExécutez le programme sans argument.
$ java conditions/ConditionalHello Hello world!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 :
Une valeur true ou false. Par exemple,
if(true).Une variable de type boolean . Par exemple,
if(myVar)oùmyVarest de type boolean .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); // -> trueequals 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 // -> trueEnfin, 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 deexpression1 && expression2n'est vrai que siexpression1est vraie ETexpression2est également vraie.||OU logique.
Le résultat est vrai si au moins une des parties participantes est vraie.
Exemple : le résultat deexpression1 || expression2est vrai siexpression1est vraie OUexpression2est 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!expression1est vrai siexpression1est fausse ; le résultat est faux siexpression1est 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 // -> trueLes 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// -> falseComme 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 // -> trueComme pour les opérateurs numériques, utilisez les parenthèses ( () ) pour changer l'ordre :
(true && false) || true // -> true
!(true && false || !true) // -> truePour 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 > 34Dans 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.lengthn'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 !
Prêt à coder ? Pour accéder à l’exercice, suivez ce lien.
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 commetrue.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.
