Leçons de niveau 14

Java/Boucles et structures conditionnelles

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Boucles et structures conditionnelles
Icône de la faculté
Chapitre no 5
Leçon : Java
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 : Boucles et structures conditionnelles
Java/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[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é.

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

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 pa 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]

  • 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[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.