|
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
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 est
la structure de test la plus basique, on la retrouve dans
tous les langages (avec une syntaxe différente...).
Elle permet d'exécuter une série d'instructions
si jamais une condition est réalisée.
La syntaxe de cette expression
est la suivante:
if (condition réalisée) {
liste d'instructions
}
else {
liste d'instructions
}
Remarques:
if ((condition1)||(condition2))
s'il n'y a qu'une instruction, les accolades
ne sont pas nécessaires...
les instructions situées dans le
bloc qui suit else sont les instructions qui seront
exécutées si la ou les conditions ne sont
pas remplies
L'instruction if
dans sa forme basique ne permet de tester qu'une condition,
or la plupart du temps on aimerait pouvoir choisir les instructions
à exécuter en cas de non réalisation
de la condition...
L'expression if ... else permet d'exécuter une
autre série d'instruction en cas de non-réalisation
de la condition.
La syntaxe de cette expression
est la suivante:
if (condition réalisée) {
liste d'instructions
}
else {
autre série d'instructions
}
Il est possible de faire
un test avec une structure beaucoup moins lourde grâce
à la structure suivante, appelée opérateur
ternaire:
(condition) ? instruction si vrai : instruction si faux
Remarques:
- la condition doit être entre des parenthèses
- Lorsque la condition est vraie, l'instruction
de gauche est exécutée
- Lorsque la condition est fausse, l'instruction
de droite est exécutée
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 Valeurs...:
Liste d'instructions
break;
default:
Liste d'instructions
break;
}
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. Le mot clé default précède
la liste d'instructions qui sera exécutée si
l'expression n'est jamais égale à une des valeurs.
|
N'oubliez pas d'insérer
des instructions break entre chaque test, ce genre
d'oubli est difficile à détecter car aucune
erreur n'est signalée...
L'instruction switch
ne fonctionne que sur des variables entières
(de type int) !
|
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.
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:
for (int i=1; i<6; i++) {
System.out.println((char)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.
D'autre part, Java autorise
la déclaration de la variable de boucle dans l'instruction
for elle-même!
Par exemple:
for (int i=0; i<10; i++) {
System.out.println((char)i);
}
|
|
- il faudra toujours vérifier
que la boucle a bien une condition de sortie (i.e
le compteur s'incrémente correctement)
- une instruction 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)
|
L'instruction while
représente un autre moyen d'exécuter plusieurs
fois la même série d'instructions.
La syntaxe de cette expression
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 structure conditionnelle, les risques
de boucle infinie (boucle dont la condition est toujours
vraie) sont grands, c'est-à-dire qu'elle risque
de provoquer un plantage du navigateur! |
Il peut être nécessaire
de faire sauter à la boucle une ou plusieurs valeurs
sans pour autant mettre fin à celle-ci.
La syntaxe de cette expression
est "continue;" (cette instruction se place
dans une 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;
while (x<=10) {
if (x == 7) {
System.out.println("Division par zéro!");
continue;
}
a = 1/(x-7);
System.out.println((char)a);
x++;
}
Il y avait une erreur dans
ce programme... peut-être ne l'avez-vous pas vue:
Lorsque x est égal à 7, le compteur ne s'incrémente
plus, il reste constamment à la valeur 7, il aurait
fallu écrire:
x=1;
while (x<=10) {
if (x == 7) {
System.out.println("division par 0");
x++;
continue;
}
a = 1/(x-7);
System.out.println((char)a);
x++;
}
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 (x=1; x<=10; x++) {
a = x-7;
if (a == 0) {
System.out.println("division par 0");
break;
}
System.out.println((char) 1/a);
}
 
|
