Utilisateur:Fasten/Java tutorial/Boucles et structures conditionnelles
|
Comme la quasi-totalité des langages de développement orienté objet, Java propose un ensemble d'instructions qui permettent d'organiser et de structurer les traitements. L'usage de ces instructions est similaire à celui rencontré dans leur équivalent dans d'autres langages. Les boucles[modifier | modifier le wikicode]Boucle while[modifier | modifier le wikicode]while (boolean) {
...// Code à exécuter dans la boucle
}
Le code est exécuté tant que le booléen est vrai. Si avant l'instruction while, le booléen est faux, alors le code de la boucle ne sera jamais exécuté.
Remarque : ce genre de boucle est utilisée lorsque l’on ne sait pas à l'avance le nombre exact de fois que la boucle devra s'exécuter notamment lors de l’utilisation de paramètres définis par l'utilisateur à l'exécution du programme. Boucle do...while[modifier | modifier le wikicode]do {
...//Code à exécuter dans la boucle
} while (boolean);
Les boucles do...while sont des variantes des boucles while. Leur particularité réside dans le fait que la condition est testée après la première exécution de la boucle. Le code est exécuté tant que la condition est satisfaite et est exécuté au moins une fois. Exemple de code utilisant la boucle do..while : class BoucleDo {
public static void main(String arg[]) {
int x = 1 ;
do {
System.out.println("Le système boucle ; pour " + x) ;
++x;
} while (x <= 100);
}
}
Boucle for[modifier | modifier le wikicode]for (initialisation; condition; modification) {
...//Code à exécuter dans la boucle
}
Les boucles for testent une condition et exécutent le bout de code attaché à la boucle tant que la condition est remplie. Remarque : les boucles for sont le plus souvent utilisées lorsque l’on sait combien de fois on souhaite exécuter le bout de code attaché à la boucle. Boucle for each[modifier | modifier le wikicode]Il existe une variante de la boucle for, la boucle for each qui permet de parcourir une collection. for (MonType mon_objet : ma_collection) {
mon_objet.ma_methode();
...//Code à exécuter dans la boucle
}
Cette boucle se lit : "Pour chaque objet Les branchements conditionnels[modifier | modifier le wikicode]La condition if...else[modifier | modifier le wikicode]Les conditions utilisent des données booléennes, true ou false. Elles vérifient si une condition est remplie. Si oui, elles effectuent un bout de code prédéfini, sinon elles exécutent un autre bout de code prédéfini ou passent directement au reste du programme. Elles ont la forme if...else .... if (boolean) {
...//Code à exécuter dans la condition
}
else if (boolean) {
...//Code à exécuter si la première condition est fausse et la deuxième vraie
}
else {
...//Code à exécuter si les précédentes conditions ne sont pas vérifiées
}
Remarque : on peut aussi avoir un conditionnel ne comprenant que la partie if(boolean){...}. Dans ce cas, si la condition est remplie, le code entre accolades sera exécuté, sinon, il ne le sera pas et le programme passe à la suite du code. Ainsi, il n’est pas nécessaire de faire apparaître un else s'il n'y a rien à exécuter si la condition n’est pas remplie. La condition switch...case[modifier | modifier le wikicode]Les conditions switch...case remplacent les conditions if..else if..else quand le nombre de else if est trop important. Elles sont en effet plus rapides à écrire. On ne peut utiliser switch...case qu'avec les types primitifs d’une taille maximum de 32 bits(byte, short, int, char) et les enum (Java 5). Si une instruction case ne contient pas de break alors les traitements associés au case suivant sont exécutés. Il est possible d'imbriquer des switch. switch(expression) {
case constant1 :
instruction1;
instruction2;
....
break;
case constant2 :
....
default :
....
}
Remarque : le dernier cas marqué par la présence de default, représentant bien entendu le cas par défaut au cas où expression ne corresponde à aucun des case, n’est pas obligatoire si l’on peut s'assurer qu' expression correspondra toujours à l'un des case. Les débranchements[modifier | modifier le wikicode]
Il permet de quitter une boucle ou un branchement. Utilisable dans tous les contrôles et flot.
S'utilise dans une boucle pour passer à l'itération suivante.
La condition Ternaire[modifier | modifier le wikicode]La condition ternaire utilise également des données booléennes, true ou false. Cette condition est une sorte de "condensé" de la structure if/else. variable = (condition) ? instruction 1 : instruction 2 ;
Si la condition (boolean) est vraie, c’est l'instruction1 située après le point d'interrogation (?) qui est effectuée; si elle est fausse, c’est l'instruction2 située après les deux points (:) qui est effectuée. La condition doit être entre parenthèses obligatoirement. int nombre =(boolean)? 1 : 2 ;
Ainsi : nombre est égal à 1 si la condition est vraie, à 2 si la condition est fausse. Il est également possible d'imbriquer des conditions ternaires: variable = (condition) ? ((autre condition)? instruction1 :instruction2):instruction3 ;
Et ainsi de suite... Il n'est cependant pas conseillé de faire un usage trop systématique de cette condition, trop peu lisible.
|
Like almost all object-oriented development languages, Java provides a set of instructions that can organize and structure treatments. The use of these instructions is similar to that encountered in their equivalent in other languages. Loops[modifier | modifier le wikicode]Whileloop[modifier | modifier le wikicode]while (boolean) {
...// Code to execute in the loop
}
The code is executed until the boolean is true. If before the while statement, the boolean is false, then the code of the loop is never executed.
 Note: This type of loop is used when it is not known in advance the exact number of times the loop will run especially when using user-defined parameters to the program . Loop do ... while[modifier | modifier le wikicode]do {
...// Code to execute in the loop
} While (boolean);
The do ... while loopsare variations ofloopswhile. Their uniqueness lies in the fact that the condition is tested after the first execution of the loop. The code is executed until the condition is satisfied and is executed at least once. Code using thedo .. while loop: {class BoucleDo
public static void main (String arg []) {
int x = 1;
do {
System.out.println ("The loop system, for" + x);
X + +;
} While (x <= 100);
}
}
Loopfor[modifier | modifier le wikicode]for (initialization, condition, change) {
...// Code to execute in the loop
}
The loopsfortest a condition and executes the code snippet attached to the loop as theconditionis not met. NOTE: The loopsforare often used when one knows how many times you want to run the piece of code attached to the loop. For Each Loop[modifier | modifier le wikicode]There is a variant of the mouthfor'For Each loopto browse a collection. for (myType my_object: my_collection) {
mon_objet.ma_methode ();
...// Code to execute in the loop
}
This loop reads: "For each object The conditional branches[modifier | modifier le wikicode]The if ... elsecondition[modifier | modifier le wikicode]Conditions using Boolean data,trueorfalse. They check whether a condition is met. If so, they perform a predefined piece of code, otherwise they run across a predefined code or go directly to the rest of the program. They have the formif ... else .... if (boolean) {
...// Code to run in the condition
}
else if (boolean) {
...// Code to execute if the first condition is false and the true second
}
else {
...// Code to execute if the preceding conditions are verified pa
}
Note: You can also have a contingent comprising only partif (boolean ){...}. In this case, if the condition is met, the code in braces will be executed, otherwise it will not be happening and the program following the code. Thus, it is not necessary to bring up aelseif there is nothing to execute if the condition is not met. Thecondition switch box ...[modifier | modifier le wikicode]The termsswitchbox ... replace the termsif .. else if .. elsewhen the number of'else if is too large. They are indeed faster to write. You can not use switch ... case withprimitive types to a maximum size of 32 bits (byte, short, int, char) and enum (Java 5). If an instructionboxdoes notbreakwhen the treatments associated with theboxfollowing are executed. It is possible to nest switch. switch (expression) {
Constant1 box:
statement1;
statement2;
....
break;
constant2 box:
....
default:
....
}
Note: The case marked by the presence ofdefault, representing of course the default ifexpressiondoes not correspond to any of thebox, is not required if the we can ensure thatexpressionalways correspond to one of thebox. The disconnections[modifier | modifier le wikicode]
There exits a loop or hook. Used in all controls and flow.
Used in a loop to move to the next iteration.
The condition Ternary[modifier | modifier le wikicode]The condition also uses ternary Boolean data,trueorfalse. This condition is a sort of "condensed" structure if / else. variable = (condition)? an instruction: Instruction 2;
If the condition (boolean) is true, it is located after statement1 the question mark (?) Is performed and if it is false, it is located statement2 after the colon (:) is carried out. The condition must be in parentheses. int count = (boolean)? 1: 2;
As follows: number is equal to 1 if the condition is true, 2 if the condition is true. It is also possible to nest ternary conditions: variable = (condition)? ((Other condition)? Statement1: statement2) instruction3;
And so on ... It is not advisable to use this condition too systematic, too difficult to read. | ||
class Calcul // la classe "Calcul"
{ // parenthèse ouvrant pour la classe
int variableGlobale = 20; // Déclaration d'une variable globale
public static void main (String [] args) // la méthode "main"
{ // parenthèse ouvrant pour la méthode
autreMéthode (variableGlobale); // instruction: la appel de méthode "autreMéthode"
} // parenthèse fermante correspondante pour la méthode
public static int autreMéthode (int paramètre) // la méthode "autreMéthode"
{ // parenthèse ouvrant pour la méthode
int variableLocale; // Déclaration d'une variable locale
variableLocale = paramètre / 2; // instruction de travail
return variableLocale; // instruction de travail
} // parenthèse fermante correspondante pour la méthode
} // parenthèse fermante correspondante pour la classe
Exercices:
| |||
