Java: Les structures conditionnelles

Qu'est-ce qu'une structure conditionnelle ?

On appelle structure conditonnelle les instructions qui permettent de tester si une condition est vraie ou non. Ces structures conditionnelles peuvent être associées à des structures qui se répètent suivant la réalisation de la condition, on appelle ces structures des structures de boucle

La notion de bloc

Une expression suivie d'un point-virgule est appelée instruction. Par exemple a++; est une instruction.
Lorsque l'on veut regrouper plusieurs instructions, on peut créer ce que l'on appelle un bloc, c'est-à-dire un ensemble d'instructions (suivies respectivement par des point-virgules) et comprises entre les accolades { et }.

Les instructions if, while et for peuvent par exemple être suivies d'un bloc d'instructions à exécuter...

L'instruction if

L'instruction if est la structure de test la plus basique, on la retrouve dans tous les langages (avec une syntaxe parfois différente...). Elle permet d'exécuter une série d'instructions lorsqu'une condition est réalisée.

La syntaxe de cette expression est la suivante :

if (condition réalisée) {
    liste d'instructions si la condition est réalisée
}
else {
    liste d'instructions si la condition n'est pas réalisée
}

Remarques:

• la condition doit être entre des parenthèses
• il est possible de définir plusieurs conditions à remplir avec les opérateurs ET et OU (&& et ||)

par exemple l'instruction suivante teste si les deux conditions sont vraies :

if ((condition1)&&(condition2))

L'instruction suivante exécutera les instructions si l'une ou l'autre des deux conditions est vraie

if ((condition1)||(condition2))

• s'il n'y a qu'une seule instruction, les accolades ne sont pas nécessaires...
• s'il n'y a pas d'instruction à exécuter lorsque la condition n'est pas réalisée, on peut enlever le else et le bloc qui suit.

Affectation conditionnelle (opérateur ternaire)

Lorsque les instructions du if et du else consistent à donner une valeur à une variable, il est possible de faire un test avec une structure beaucoup moins lourde grâce à l'opérateur ternaire :

variable  = condition ? valeur_si_vrai : valeur_si_faux

Par exemple ces deux codes sont équivalents (ils donnent à min la plus petite valeur entre a et b)

if (a<b)
   min=a;
else
   min=b;

min = a<b ? a : b;

Remarques:

• Contrairement à la boucle if, il n'est pas nécessaire que la condition soit entre parenthèses.
• Lorsque la condition est vraie, la valeur à gauche des " : " est donnée à la variable
• Lorsque la condition est fausse, la valeur à droite des " : " est donnée à la variable

L'instruction switch

L'instruction switch permet de faire plusieurs tests de valeurs sur le contenu d'une même variable. Ce branchement conditionnel simplifie beaucoup le test de plusieurs valeurs d'une variable, car cette opération aurait été compliquée (mais possible) avec des if imbriqués. Sa syntaxe est la suivante :

switch (variable) {

case valeur1 :
 Liste d'instructions
 break;

case valeur2 :
 Liste d'instructions
 break;

case valeurN... :
 Liste d'instructions
 break;

default: 
 Liste d'instructions
}

Les parenthèses qui suivent le mot clé switch indiquent une expression dont la valeur est testée successivement par chacun des case. Lorsque l'expression testée est égale à une des valeurs suivant un case, la liste d'instruction qui suit celui-ci est exécuté. Le mot clé break indique la sortie de la structure conditionnelle, s'il n'est pas mis alors toutes les instructions suivantes seront également exécutées. Le mot clé default est à mettre à la fin, et précède la liste d'instructions à exécuter si l'expression n'est jamais égale aux valeurs précédentes.

N'oubliez pas d'insérer les instructions break entre chaque test, leur absence est difficile à détecter puisqu'il ne s'agit pas formellement d'une erreur...

L'instruction switch ne fonctionne que sur des types simples (int, short, char ou byte) !

Les boucles

Les boucles sont des structures qui permettent d'exécuter plusieurs fois la même série d'instructions jusqu'à ce qu'une condition ne soit plus réalisée...
On appelle parfois ces structures instructions répétitives ou bien itérations.
La façon la plus commune de faire une boucle, est de créer un compteur (une variable qui s'incrémente, c'est-à-dire qui augmente de 1 à chaque tour de boucle) et de faire arrêter la boucle lorsque le compteur dépasse une certaine valeur.

Remarque : les trois boucles de base sont équivalentes, il est toujours possible de réécrire chacune d'elle avec l'une des deux autres.

La boucle for

L'instruction for permet d'exécuter plusieurs fois la même série d'instructions: c'est une boucle !

Dans sa syntaxe, il suffit de préciser le nom de la variable qui sert de compteur (et éventuellement sa valeur de départ, la condition sur la variable pour laquelle la boucle s'arrête (basiquement une condition qui teste si la valeur du compteur dépasse une limite) et enfin une instruction qui incrémente (ou décrémente) le compteur.

La syntaxe de cette expression est la suivante :

for (compteur; condition; modification du compteur) {
 liste d'instructions
}

Par exemple :

int i;
for (i=1; i<6; i++) {
   System.out.println(i);
}

Cette boucle affiche 5 fois la valeur de i, c'est-à-dire 1, 2, 3, 4, 5
Elle commence à i=1, vérifie que i est bien inférieur à 6, etc... jusqu'à atteindre la valeur i=6, pour laquelle la condition ne sera plus réalisée, la boucle s'interrompra et le programme continuera son cours.

Remarque : Java autorise la déclaration de la variable de boucle dans l'instruction for elle-même. On peut même déclarer d'autres variables en même temps, par exemple pour définir la condition d'arrêt :

for (int i=0, n=10; i<n; i++) {
   System.out.println(i);
}

Remarques :

• il faut toujours s'assurer que la boucle s'arrête bien à un moment
• une instruction d'affichage System.out.println(); dans votre boucle est un bon moyen pour vérifier la valeur du compteur pas à pas en l'affichant !
• il faut bien compter le nombre de fois que l'on veut faire exécuter la boucle:
  • for(i=0; i<10; i++) exécute 10 fois la boucle (i de 0 à 9)
  • for(i=0; i<=10; i++) exécute 11 fois la boucle (i de 0 à 10)
  • for(i=1; i<10; i++) exécute 9 fois la boucle (i de 1 à 9)
  • for(i=1; i<=10; i++) exécute 10 fois la boucle (i de 1 à 10)

La boucle while

La boucle while représente un autre moyen d'exécuter plusieurs fois la même série d'instructions.

La syntaxe est la suivante :

while (condition réalisée) {
   liste d'instructions
}

Cette instruction exécute la liste d'instructions tant que (while est un mot anglais qui signifie tant que) la condition est réalisée.
La condition de sortie pouvant être n'importe quelle condition, il est souvent moins aisé de savoir si la boucle s'arrête, mais il est important de toujours s'en assurer.

La boucle do while

La boucle do while est une variante de la boucle while, où la condition d'arrêt est testée après que les instructions aient été exécutées.

La syntaxe est la suivante :

do {
   liste d'instructions
} while (condition réalisée);

Attention : n'oubliez pas de mettre un point-virgule après la condition de la boucle do while, mais n'en mettez surtout pas à une boucle for ou à une boucle while.

La boucle for each

La boucle for each n'est pas une boucle comparable aux trois précédentes, car elle s'utilise dans un cadre très particulier, lorsqu'il faut itérer les différents éléments d'un ensemble (un tableau, une liste etc...).

La syntaxe est la suivante :

for (type variable : ensemble) {
    instructions
}

Par exemple pour afficher tous les éléments d'un tableau d'entiers, ces deux codes sont équivalents :

for (int i=0, n=tableau.length; i<n; i++)
    System.out.println(tableau[i]);

for (int e : tableau)
    System.out.println(e);

Dans le premier code on itérait les indices du tableau, alors que dans le deuxième, on itère directement sur les éléments du tableau.

Remarques :

• Dans la majorité des cas où elle peut s'utiliser, la boucle for each est plus rapide qu'une boucle for.
• On a ici un contrôle moindre sur l'ordre des éléments, mais Java assure que tous les éléments seront utilisés (on a pas à compter soi même le nombre d'éléments) et qu'ils seront pris "dans l'ordre" (lorsque cet ordre existe).

Saut inconditionnel

Il peut être nécessaire de faire sauter une ou plusieurs valeurs à la boucle sans pour autant mettre fin à celle-ci.

La syntaxe de cette expression est "continue;" (cette instruction se place dans la boucle), on l'associe généralement à une structure conditionnelle, sinon les lignes situées entre cette instruction et la fin de la boucle seraient obsolètes.

Exemple : Imaginons que l'on veuille imprimer pour x allant de 1 à 10 la valeur de 1/(x-7) ... il est évident que pour x=7 il y aura une erreur. Heureusement, grâce à l'instruction continue il est possible de traiter cette valeur à part puis de continuer la boucle !

x=1;

for (int x=0; x<=10; x++) {
   if (x == 7) {
      System.out.println("Division par zéro!");
      continue;
   }

   double a = 1.0/(x-7);
   System.out.println(a);
}

Arrêt inconditionnel

A l'inverse, il peut être voulu d'arrêter prématurément la boucle, pour une autre conditon que celle précisée dans l'en-tête de la boucle. L'instruction break permet d'arrêter une boucle (for ou bien while). Il s'agit, tout comme continue, de l'associer à une structure conditionnelle, sans laquelle la boucle ne ferait jamais plus d'un tour !

Dans l'exemple de tout à l'heure, par exemple si l'on ne savait pas à quel moment le dénominateur (x-7) s'annule (bon...OK...pour des équations plus compliquées par exemple) il serait possible de faire arrêter la boucle en cas d'annulation du dénominateur, pour éviter une division par zéro!

for (int x=1; x<=10; x++) {
   a = x-7;

   if (a == 0) {
      System.out.println("division par 0");
      break;
   }

   System.out.println(1.0/a);
}