Utilisateur:Fasten/Java tutorial/Boucles et structures conditionnelles

From Wikiversité
Jump to navigation Jump to search
Début de la boite de navigation du chapitre
Boucles et structures conditionnelles
Icône de la faculté
Chapitre no 5
Leçon : Java tutorial
Chap. préc. :Méthodes
Chap. suiv. :Tableaux
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Java tutorial : Boucles et structures conditionnelles
Fasten/Java tutorial/Boucles et structures conditionnelles
 », n'a pu être restituée correctement ci-dessus.

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[edit | edit source]

Boucle while[edit | edit source]

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é.

Panneau d’avertissement Ne pas mettre de ; après l'instruction sinon le corps 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[edit | edit source]

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[edit | edit source]

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[edit | edit source]

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 mon_objet du type MonType de la collection ma_collection alors... "

Les branchements conditionnels[edit | edit source]

La condition if...else[edit | edit source]

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[edit | edit source]

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[edit | edit source]

  • Break

Il permet de quitter une boucle ou un branchement. Utilisable dans tous les contrôles et flot.

  • Continue

S'utilise dans une boucle pour passer à l'itération suivante.


break et continue peuvent s'exécuter avec des blocs nommés. Il est possible de préciser une étiquette pour indiquer le point de retour lors de la fin du traitement déclenché dans le break.


Une étiquette est un nom suivi d’un des deux points qui définit le début d’une instruction.

La condition Ternaire[edit | edit source]

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[edit | edit source]

Whileloop[edit | edit source]

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.


Avertissement :
Do not put; after the trial if the loop body will never be 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[edit | edit source]

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[edit | edit source]

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[edit | edit source]

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 my_object type myType from the collection my_collection so ..."

The conditional branches[edit | edit source]

The if ... elsecondition[edit | edit source]

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 ...[edit | edit source]

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[edit | edit source]

  • ''''' Break

There exits a loop or hook. Used in all controls and flow.

  • ''''' Continue

Used in a loop to move to the next iteration.


Breakandcontinuouscan run with named blocks. It is possible to specify a label to indicate the point of return at the end of treatment triggered thebreak.


A label is a name followed by a colon, which defines the beginning of a statement.

The condition Ternary[edit | edit source]

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:

  • Faites la méthode "autreMéthode" plus long:
    • Ajoutez une condition if...else: Retournez -1 si le paramètre est supérieure à 50.
    • Ajoutez une condition switch...case: Retournez -1 si le paramètre est 5, 10, 15 ou 20.
    • Ajoutez une boucle do...while: Réduisez la valeur par un dans une boucle; retournez quand il peut être divisé par une constante.
    • Ajoutez une boucle for: Initialisez une variable locale avec un; multipliez la variable par deux aussi souvent que le paramètre indique. Qu'est-ce que c’est le nom pour la calculation?