Les conditions


Les conditions
Nous abordons ici un des chapitres les plus importants et les plus utilisés.
Vous allez voir que tous vos projets ne sont que des enchaînements et des imbrications de conditions et de boucles (partie suivante).
Dans une classe, la lecture et l'exécution se font de façon séquentielle. C'est-à-dire en suivant, ligne par ligne. Avec les conditions, nous allons pouvoir gérer différents cas de figure, sans pour autant lire tout le code.
Assez de belles paroles ! Rentrons tout de suite dans le vif du sujet.
Sommaire du chapitre :
  • Les opérateurs logiques
  • La structure if....else
  • Les conditions multiples
  • La structure switch
  • La condition ternaire

Les opérateurs logiques

Ceux-ci sont surtout utilisés lors de conditions (SI****** alors fait ceci*****) pour tester des vérités ou des contrevérités ! Mais nous verrons plus en détails leur utilité dans un autre chapitre ! Je vous les colle ici car ils sont faciles à mémoriser ; et puis comme ça, c'est fait, on n'en parlera plus.

== permet de tester l'égalité. Prenons l'exemple complètement inutile suivant (en français, pour le code Java, ce sera plus tard...).
SI bleu == bleu alors fait ceci.......

!= pas égal ou encore différent de. Je pense que c'est assez parlant, non ?

< strictement inférieur.

<= inférieur ou égal. Vous l'aviez déjà trouvé, je suis sûr ! ! !

> strictement supérieur.

>= eh oui, voici son grand frère, le majestueux supérieur ou égal !

&& voici l'opérateur ET. Permet de préciser une condition.

|| est le cousin du ET, le OU. Même combat que le précédent.

? : L'opérateur ternaire, pour celui-ci vous comprendrez mieux avec un exemple... vers la fin de ce chapitre.
Comme je vous l'ai dit dans la partie précédente, les opérations en Java sont soumises à un ordre de priorité. Tous ces opérateurs sont soumis à cette règle, de la même manière que les opérateurs arithmétiques...


Il n'y a pas grand-chose à dire sur ces opérateurs sans un exemple concret, donc allons-y.

La structure if....else

Pour commencer, je vais vous expliquer à quoi servent ces structures conditionnelles. Elles servent tout simplement à pouvoir constituer un programme, en examinant les différents cas de figure que celui-ci propose.
Je m'explique : imaginons un programme qui demande à un utilisateur de rentrer un nombre réel (qui peut être soit négatif, soit nul, soit positif). Les structures conditionnelles vont nous permettre de gérer ces trois cas de figure.

La structure de ces conditions ressemble à ça :
Code : Java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
 
if(//condition)
{
.....// exécution des instructions si la condition est remplie
.....
.....
}
else
{
....// exécution des instructions si la condition n'est pas remplie
....
....
}


Ceci peut se traduire par "SI... SINON...".

Mettons notre petit exemple du dessus en pratique :

Code : Java 
1
2
3
4
5
6
7
 
int i = 10;
 
if (i < 0)
        System.out.println("Le nombre est négatif");
 
else
        System.out.println("Le nombre est positif");


Testez ce petit code, et vous verrez comment il fonctionne (par exemple, avec la fonction de pas à pas).
Dans ce cas, notre classe affiche que "le nombre est positif".
Expliquons un peu ce qui se passe :
  • dans un premier temps, la condition du if est testée... (qui dit SI i est strictement inférieur à 0).
  • Vu que celle-ci est fausse, le programme exécute le else.

Attends un peu ! Lorsque tu nous a présenté la structure des conditions, tu as mis des accolades et là, tu n'en mets pas...

Bien observé. En fait, les accolades sont la structure "normale" des conditions mais, lorsque le code à l'intérieur d'une d'entre elles n'est composé que d'une seule ligne de code, les accolades deviennent facultatives.


Comme nous avons l'esprit perfectionniste, nous voulons que notre programme affiche "le nombre est nul", lorsque i est égal à 0 ; nous allons donc rajouter une condition.
Comment faire... La condition du if est remplie si le nombre est strictement négatif, ce qui n'est pas le cas ici puisque nous allons le mettre à 0, le code contenu dans la clause else est donc exécuté si le nombre est égal à 0 et strictement supérieur à 0.
Il nous suffit de rajouter une condition à l'intérieur de la clause else. Comme ceci :

Code : Java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
 
int i = 0;
        if (i < 0)
                System.out.println("Ce nombre est négatif !");
 
        else
        {
                if(i == 0)
                        System.out.println("Ce nombre est nul !!");
 
                else
                        System.out.println("Ce nombre est positif !!");
 
        }


Ici, la seule petite chose qui devrait vous interpeler, c'est l'imbrication d'une structure if... else dans un else. Et encore, parce que je suis tolérant...
Vous voyez aussi que le code à l'intérieur de la première clause if ne contient qu'une seule ligne de code [=> accolades facultatives] et que la clause else correspondante, elle, a plusieurs ligne en son sein [=> on entoure donc le code de cette dernière avec des accolades]. Les clauses à l'intérieur du premier else n'ont, elles aussi, qu'une seule ligne de code [=> accolades facultatives].

Vous verrez vite que vos programmes ne seront que des imbrications de conditions.
Je vous fais voir une autre manière de le faire :


Code : Java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
 
int i = 0;
        if (i <= 0)
        {       
                if(i == 0)
                  System.out.println("Ce nombre est nul !!");
 
                else
                  System.out.println("Ce nombre est négatif !");
        }
        else
           System.out.println("Ce nombre est positif !!");

Je pense que ce code parle de lui-même...
Ici, la clause du if est remplie si i est INFÉRIEUR OU ÉGAL à 0, i vaut 0 la condition est remplie. La suite, vous la connaissez.

Maintenant que vous avez tout compris, je vais vous montrer une autre façon de faire ce code, avec le même résultat (encore heureux !). En ajoutant juste un petit SINON SI. Regardez bien la magie.

Code : Java 
1
2
3
4
5
6
7
8
9
 
int i = 0;
  if (i < 0)
    System.out.println("Ce nombre est négatif !");      
  
  else if(i > 0)
    System.out.println("Ce nombre est positif !!");           
 
  else  
    System.out.println("Ce nombre est nul !!");


Alors ? Explicite, n'est-ce pas ?
  • SI i est strictement négatif => exécution du code.
  • SINON SI i est positif => exécution du code.
  • SINON i est forcément nul => exécution du code.

Il faut absolument donner au else if une condition pour qu'il fonctionne. Sans cela, Eclipse vous mettra de zolies vagues rouges sous votre else if.
Vous en avez sûrement déjà vu à de nombreuses reprises...


Par contre, je vais TRÈS FORTEMENT INSISTER sur un point : regardez l'affichage du code : remarquez le petit décalage entre ma première condition et ma deuxième.
On appelle ceci l'indentation, et comme c'est écrit en gros, en gras et en rouge, c'est que c'est hyper important !

En effet, pour vous repérer dans vos futurs programmes, cela sera très utile. Imaginez deux secondes que vous avez un programme de 700 lignes avec 150 conditions, et que tout est écrit le long du bord gauche. Vous allez vous amuser pour retrouver où commence et où se termine une condition. Je vous le garantis !
Vous n'êtes pas obligés de le faire, mais je vous assure que vous y viendrez.
À titre d'information, n'essayez pas de faire des comparaisons de String à ce stade. Je vous expliquerai la marche à suivre lors du chapitre sur les fonctions.


Je vois que vous apprenez vite : nous pouvons donc passer à la vitesse supérieure !
Voyons tout de suite les conditions multiples.

Les conditions multiples

Avant de commencer, vous devez savoir qu'on ne peut pas tester l'égalité de chaînes de caractères !
Du moins pas comme je vous l'ai montré ci-dessus... Nous aborderons ce point plus tard.


Derrière ce nom barbare, se trouve simplement une ou deux (ou X) conditions en plus dans un if, ou un else if. Nous allons maintenant utiliser les opérateurs logiques que nous avons vus au début. Pfiou ! C'est vieux !
Alors dans ce cas :
  • SI c'est vieux et ça va aller => alors on continue.
  • SINON SI c'est vieux et je ne me rappelle plus => on va relire le début !
  • SINON, allons-y tout de suite !


Voilà un bel exemple de conditions multiples ! Et je n'ai pas été la chercher loin, celle-là. Elle ressemble beaucoup à la condition de notre programme (plus haut).
Je sais par expérience qu'on comprend mieux avec un exemple ; donc, allons-y...

Maintenant, nous allons vérifier si un nombre donné appartient à un intervalle connu ; par exemple, savoir si un nombre est entre 50 et 100. Nous allons essayer de résoudre ce problème avec les outils que nous avons. En gros, ça donnerait quelque chose comme ça :

Code : Java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
 
int i = 58;
 if(i < 100) 
 {
   if(i > 50)
     System.out.println("Le nombre est bien dans l'intervalle");
   
   else
    System.out.println("Le nombre n'est pas dans l'intervalle");
 }
 
 else
   System.out.println("Le nombre n'est pas dans l'intervalle");


Rien de bien compliqué : notre objectif dans ce programme est de repérer si un nombre répond à deux conditions, il faut :
  • qu'il soit inférieur à 100
  • qu'il soit supérieur à 50.


Eh bien les conditions multiples peuvent éliminer deux lignes dans notre précédent code. Regardez plutôt :
Code : Java 
1
2
3
4
5
6
 
int i = 58;
 if(i < 100 && i > 50) 
   System.out.println("Le nombre est bien dans l'intervalle");
 
 else
   System.out.println("Le nombre n' est pas dans l'intervalle");


Nous avons utilisé l'opérateur && qui signifie ET. Donc, la condition de notre if est devenu :
si i est inférieur à 100 ET supérieur à 50, alors la condition est remplie.
Avec l'opérateur &&, la clause est remplie si et seulement si les conditions formant la clause sont toutes remplies ; si l'une des conditions n'est pas vérifiée, la clause sera considérée comme fausse.
Ici, nous avons deux conditions liées par l'opérateur && : les deux conditions doivent être vraies pour que la clause soit remplie !

Cet opérateur vous initie à la notion d'intersection d'ensembles. Ici, nous avons deux conditions qui définissent chacune un ensemble :
  • i < 100 définit un ensemble des nombres inférieurs à 100 (59 ou 45 ou 0 ou -1000000)
  • i > 50 définit les nombres supérieurs à 50 (58 ou 79 ou 101 ou 1000000).

L'opérateur && permet de faire intersection de ces ensembles. La condition regroupe donc les nombres qui appartiennent à ces deux ensembles, ici les nombres de 51 à 99 inclus.
Réfléchissez bien à l'intervalle que vous voulez définir. Regardez ce code :
Code : Java 
1
2
3
4
5
6
 
int i = 58;
 if(i < 100 && i > 100) 
   System.out.println("Le nombre est bien dans l'intervalle");
 
 else
   System.out.println("Le nombre n'est pas dans l'intervalle");

Ici, la condition ne sera JAMAIS remplie car, personnellement, je ne connais aucun nombre qui est à la fois plus petit que 100 et plus grand !
Par contre, si on remplace les inférieur / supérieur stricts par des inférieur / supérieur ou égal, le seul nombre qui puisse valider la clause est 100, car c'est le seul qui appartienne aux deux ensembles.


Reprenez le code précédent, celui-ci où la condition ne sera jamais remplie...
Maintenant, remplacez l'opérateur && par || (pour mémoire, c'est un OU).
À l'exécution du programme et après plusieurs tests de valeur pour i, vous pouvez vous apercevoir que tous les nombres remplissent cette condition, sauf 100.

Nous vérifions ici si le nombre choisi appartient à L'UN DES DEUX ensembles ou aux DEUX. On cherche un nombre strictement inférieur à 100 OU un nombre strictement supérieur à 100 : donc tous les nombres remplissent cette condition, SAUF 100.
Et là, si nous remplaçons les inégalités strictes par des inégalités larges, tous les nombres remplissent la condition, car 100 fera partie des deux ensembles.

Ici, un seul opérateur large suffit, car si 100 appartient à l'un des deux ensembles, la condition sera remplie car le nombre doit appartenir à l'un ou l'autre, ou aux deux intervalles !

La structure switch

Cette instruction est un peu particulière... par sa syntaxe, et son utilisation.
Le switch est surtout utilisé lorsque nous voulons des conditions "à la carte". Le meilleur exemple se trouve sur le site du Zér0 : ce n'est pas tant la note, mais l'appréciation qui suit qui est définie avec un switch.
Prenons l'exemple d'un questionnaire de 4 questions, sur 5 points chacune, qui nous donne 5 notes, et donc 5 appréciations possibles, comme ce qui suit :
  • 0/20 : tu peux revoir ce chapitre, petit Zér0 !
  • 5/20 : concentre-toi un peu plus... Allez, persévère !
  • 10/20 : Je crois que tu as compris l'essentiel ! Viens relire ce chapitre à l'occasion.
  • 15/20 : BRAVO ! Voilà une note encourageante pour moi qui essaie de vous apprendre des trucs !
  • 20/20 : IL EST VRAIMENT... IL EST VRAIMENT.... IL EST VRAIMENT PHHHEEEEEENOOOOOMMEEEEEENAAAALLLL!


Dans ce genre de cas, on utilise un switch pour alléger un peu le code, et surtout pour éviter des else if à répétition.
J'en conviens : nous pouvons très bien arriver au même résultat avec des if qu'avec un switch. Mais il faut le voir tout de même.


Je vais vous expliquer comment se construit la syntaxe d'un switch ; puis nous allons le mettre en pratique tout de suite après.

Syntaxe

Code : Java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
 
switch (/*variable*/)
     {
       case /*argument*/:
         /*action*/;
         break;
         
       case /*argument*/: 
         /*action*/;
         break;
         
       case /*argument*/:
         /*action*/;
         break;  
 
        default:/*action*/;             
     }

Cette expression s'exécute comme suit :
  • la classe évalue l'expression figurant après le switch (ici /* variable*/)
  • la classe cherche ensuite s'il existe une languette (case /*valeur possible de la variable */:), dans le bloc d'instructions, correspondant à la forme de /*variable*/
  • s'il existe une languette, la requête figurant dans celle-ci sera exécutée
  • sinon, on passe à la languette suivante !
  • Si aucun cas n'a été trouvé, la classe va exécuter ce qui se trouve dans l'instruction default:/*action*/;, voyez ceci comme une sécurité.

Notez bien la présence de l'instruction break;. Celle-ci permet de sortir du switch si une languette a été trouvée pour le cas concerné. Pour mieux juger de l'utilité de cette instruction, enlevez tous les break;, et compilez votre programme. Vous verrez le résultat...


Voilà un exemple de switch que vous pouvez essayer :

Code : Java  
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
int nbre = 5; 
 
     switch (nbre)
     {
       case 1: System.out.println("Ce nombre est tout petit");
         break;
 
       case 2: System.out.println("Ce nombre est tout petit");
         break;
 
       case 3: System.out.println("Ce nombre est un peu plus grand");
         break;
 
       case 4: System.out.println("Ce nombre est un peu plus grand");
         break;
 
       case 5: System.out.println("Ce nombre est la moyenne");
         break;
 
       case 6: System.out.println("Ce nombre est tout de même grand");
         break;
 
       case 7: System.out.println("Ce nombre est grand");
         break;
 
      default: System.out.println("Ce nombre est très grand, puisqu'il est compris entre 8 et 10");
 
     }


Ici, vous devriez commencer à voir l'intérêt de l'indentation ==> je crois que je l'aurai assez dit...

Si vous avez essayé ce programme en enlevant l'instruction break;, vous avez dû vous rendre compte que le switch exécute le code contenu dans le case 5: mais aussi dans tous ceux qui suivent !
L'instruction break; permet de sortir de l'opération en cours. Dans notre cas, on sort de l'instruction switch, mais vous verrez une autre utilisation au chapitre suivant.
L'instruction switch ne prend que des entiers ou des caractères en paramètre... C'était important de le dire.


Je pense que c'est assez clair ! Vous pouvez voir le même résultat lorsque vous faites des "scores" différents dans vos QCM.
Surtout, pensez bien à l'instruction break;, et aussi à vos ;.

Si tout le monde suit, voyons à quoi ressemble les conditions ternaires !

La condition ternaire

Celle-ci est un peu particulière mais très pratique.
Avec elle, vous pourrez condenser certaines parties de code, mais attention à ne pas en abuser sinon votre code sera indigeste.

La particularité des conditions ternaires réside dans le fait que trois opérandes (variable ou constante) sont mises en jeu mais aussi que ces conditions sont employées pour affecter des données dans une variable. Voici à quoi ressemble la structure de ce type de condition :

Code : Java 
1
2
 
int x = 10, y = 20;
int max = (x < y) ? y : x ; //Maintenant max vaut 20


Décortiquons ce qu'il se passe :
  • Nous cherchons à affecter une valeur à notre variable max, mais de l'autre côté de l'opérateur d'affectation se trouve une condition ternaire...
  • Ce qui se trouve entre parenthèses est évalué : est-ce que x est plus petit que y, donc deux cas de figure se profilent à l'horizon :
    • Si la condition renvoie true (vrai), donc qu'elle est vérifiée, la valeur qui se trouve après le ? sera affectée.
    • Sinon, la valeur se trouvant après le symbole : sera affectée.
  • L'affectation est faite, vous pouvez utiliser votre variable max.

Attention : La condition que vous évaluez doit retourner soit vrai soit faux !


Pour vous faire voir l'utilité de ce genre d'instruction, voilà à quoi pourrait ressembler un code qui fait exactement la même chose que l'exemple que je vous ai fourni :

Code : Java 
1
2
3
4
5
 
int x = 10, y = 20, max = 0;
if(x < y)
  max = y;
else
  max = x;


Vous pouvez aussi faire des calculs (ou autre chose) avant d'affecter les valeurs, donc ce code fonctionne :
Code : Java 
1
2
 
int x = 10, y = 20;
int max = (x < y) ? y * 2 : x * 2 ; //Ici max vaut 2 * 20 soit 40


J'espère que vous y voyez plus clair...
Cependant, vous devez savoir autre chose, comme je vous l'ai dit lorsque vous avez lu le chapitre sur les opérateurs, vous pouvez utiliser le modulo pour savoir si un nombre est pair ou impair. Avec le code suivant, vous allez voir que la variable que nous souhaitons affecter n'a pas de lien avec la condition présente dans l'instruction ternaire.

Pour preuve nous allons affecter un String grâce à une condition sur deux int :

Code : Java 
1
2
3
4
 
int x = 10;
String type = (x % 2 == 0) ? "C' est pair" : "C' est impair" ; //Ici type vaut "C' est pair"
x = 9;
type = (x % 2 == 0) ? "C' est pair" : "C' est impair" ; //Ici type vaut "C' est impair"


Avant de vous laisser, vous ne devez pas oublier que la valeur que vous allez affecter à votre variable DOIT ETRE DU MEME TYPE QUE VOTRE VARIABLE ! !

Vous devez aussi savoir que rien ne vous empêche de mettre une condition ternaire dans une condition ternaire:
Code : Java 
1
2
3
4
5
 
int x = 10, y = 20;
int max = (x < y) ? (y < 10) ? y % 10 : y * 2 : x ; // max vaut 40
//Pas très facile à lire... 
//Vous pouvez entourer votre deuxième instruction ternaire avec des parenthèses pour mieux voir
max = (x < y) ? ((y < 10) ? y % 10 : y * 2) : x ; // max vaut 40
Je vous conseille d'utiliser ce que vous venez de voir avec ce que vous avez appris lors du chapitre précédent ! Vous verrez tout de suite qu'il est assez pénible de lancer l'application à chaque fois.
Rappelez-vous de ce que je vous ai dit sur l'exécution séquentielle d'un programme. Une fois arrivé à la fin, le programme s'arrête...

Si seulement on pouvait répéter des morceaux de codes... Ah ! Mais c'est ce que nous verrons dans le chapitre suivant...
Je crois que vous êtes d'attaque pour le prochain chapitre : les boucles !

// // 0 comments //

0 comments to "Les conditions"

Post a Comment

About This Blog

Aller au debut de la page