| PrécédentJava - Opérateurs | Java: Les structures conditionnelles | SuivantClasses Java |
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))L'instruction suivante exécutera les instructions si l'une ou l'autre des deux conditions est vraie
if ((condition1)||(condition2))
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:
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 types simples (int, short, char ou byte) !
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);
}
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);
}
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);
}
"java plug-in 1.6.0_16" jp2iexp.dll Arraylist java Constructeur java Excel mise en forme conditionnelle Exercices en pascal sur les structures conditionnelles Héritage multiple java Java main Java random Java tableau string Java update Java.com Split java Structure conditionnelle Structure conditionnelle algo Structure de structure en c Structure fifo java Telecharger java script Télécharger java
