Vous êtes sur la page 1sur 7

Segment 9 : Java sans objet : la sélection et la répétition

(4/5)

16 Concepts de base....................................................................................................................59
16.1 Structure de contrôle ..........................................................................................................59
16.1.1 Sélection ....................................................................................................................59
16.1.2 Répétition...................................................................................................................61

Marc Tizzano (EMN) 58


16 Concepts de base

16.1 Structure de contrôle

16.1.1 Sélection

Nous avons déjà vu le if et le if/else. La structure que nous allons voir permet de simplifier
(dans certains cas) une suite de if/else successifs. Supposons que l’on veuille écrire une
méthode qui retourne une chaîne de caractères représentant le nom d’un mois. Une façon
de l’écrire serait la suivante :

static public String nomDuMois(int n) {


String nom;
if (n == 1) {
nom = "JANVIER";
} else {
if (n == 2) {
nom = "FEVRIER";
} else {
if (n == 3) {
nom = "Mars";
} else {

if (n == 12) {
nom = "Décembre";
} else {
nom = "C'est pas un mois !";
}

}
}
}
return nom;
}

Cette suite de if/else successifs n’est pas très lisible. On peut améliorer la lisibilité en
supprimant quelques accolades et en modifiant l'indentation :

Marc Tizzano (EMN) 59


static public String nomDuMois(int n) {
String nom;
if (n == 1) {
nom = "JANVIER";
} else if (n == 2) {
nom = "FEVRIER";
} else if (n == 3) {
nom = "MARS";

} else if (n == 12) {
nom = "DECEMBRE";
} else {
nom = "C'est pas un mois";
}
return nom;
}

Mais la structure la plus adaptée est la structure à choix multiple (switch). La forme
générale de la structure est :

switch (expr) {
case expr_const1 : instructions;
case expr_const2 : instructions;
case expr_const3 : instructions;
default : instructions;
}

Avec expr une expression qui retourne une valeur de type entier ou de type caractère, et
expr_const un entier constant ou un caractère constant. La va leur retournée par expr est
comparée aux expr_const et dès qu'une étiquette est trouvée, toutes les instructions
suivantes sont exécutées jusqu'à arriver à une instruction break ou à l'étiquette default.
Quand la valeur retournée par expr est différente des valeurs des expr_const, les
instructions qui suivent l'étiquette default sont exécutées. Si l'étiquette default n'est pas
présente, aucune instruction n'est exécutée.

Le programme suivant permet de définir le nombre de jours d'un mois (on ne tient pas
compte des années bissextiles).

switch (numDuMois) {
case 3: case 5: case 7:case 8: case 10:case 12 : nbreJours= 31; break;
case 4:case 6: case 9: case 11: nbreJours=30; break;
case 2: nbreJours=28; break;
default: nbreJours=0; break;
}

Le break qui suit le case 2 : est facultatif. Néanmoins, on l'écrira par souci de lisibilité.
Même remarque pour celui lié à l'étiquette default.

Marc Tizzano (EMN) 60


INFO09EXE01
Ecrivez une méthode qui retourne true si le caractère passé en paramètre est une voyelle.
Pour cela vous utiliserez un switch.

La méthode nomDuMois() peut maintenant s’écrire :

static public String nomDuMois(int n) {


String nom;
switch (n) {
case 1:nom = "JANVIER"; break;
case 2:nom = "FEVRIER"; break;
case 3:nom = "MARS"; break;
……
case 12: nom = "DECEMBRE";break;
default: nom = "C’est pas un mois";break;
}
return nom;
}

Notez que la façon la plus élégante de traiter ce problème est d’utiliser les constantes, on a
alors le schéma de programmation suivant :

static final int JANVIER = 1, FEVRIER = 2, MARS = 3,…


DECEMBRE = 12;

static public String nomDuMois2(int n) {


String nom;
switch (n) {
case JANVIER:nom = "JANVIER"; break;
case FEVRIER:nom = "FEVRIER"; break;
case MARS:nom = "MARS"; break;
……
case DECEMBRE: nom = "DECEMBRE";break;
default: nom = "C’est pas un mois";break;
}
return nom;
}

16.1.2 Répétition

Une structure de répétition souve nt utilisée est la boucle for.

for(expr1;expr2;expr3)
instructions;

Marc Tizzano (EMN) 61


Elle est équivalente à :

expr1;
while (expr2) {
instructions;
expr3;
}

Après exécution de expr1, tant que expr2 est vrai, elle exécute instructions puis expr3.

Néanmoins les utilisations les plus courantes sont les suivantes :

for(var= debut; var <= fin; var = var+increment)


instructions;
ou
for(var= debut; var >= fin; var = var-increment)
instructions;

Elle sert alors à exécuter instructions un nombre fini de fois en incrémentant ou


décrémentant un compteur.

Bug potentiel
Le programmeur débutant écrit souvent une boucle for de la manière suivante :
for(int var = debut; var==fin; var = var+increment)…
Cela est incorrect car expr2 est une expression de continuation, la boucle est exécutée tant
que expr2 est vrai. Vous pouvez essayer ce code incorrect pour vous persuader de son
incorrection.

Bug potentiel
Souvent par erreur, le programmeur sépare les expressions par des "," et écrit :
for(var= debut, var >= fin, var = var-increment)
La encore essayer au moins une fois ce code !

Le programme suivant affiche les puissances de 2 de 2 à 2n .

long x=1;
int i;
for(i=1; i <=n; i=i+1) {
x=x*2;
System.out.println(i+ “--->” + x);
}

Marc Tizzano (EMN) 62


Notez que cela peut s’écrire de façon plus concise :

long x=1;
for(int i=1; i <=n; i++) {
System.out.println(i+ “--->” + (x*=2));
}

Notez la déclaration de la variable i dans la boucle for. Cela permet à i d’être locale à la
boucle for. Elle peut ainsi être utilisée dans une autre boucle. Par contre sa valeur est
perdue à la sortie de la boucle.

L'instruction de répétition do/while fonctionne comme la boucle while, mais le test de


l'expression conditionnelle est effectué à la fin. Avec un do/while le corps de la boucle est
exécuté au moins une fois.

Supposez que votre programme demande à l'utilisateur une valeur entre 0 et 11 et effectue
une action dans ce cas. Si la valeur four nie ne respecte pas cette condition, le programme
doit demander une nouvelle valeur. Avec un while le programme s'écrirait :

int nombre = 12;//Valeur fictive


while ((nombre <3 || nombre >11)) {
System.out.print("Entrez une valeur comprise entre 3 et 11 :");
nombre = Clavier.lireInt();
}
System.out.println("Enfin…");

Dans l'exemple précédent le programmeur donne une valeur fictive à nombre la première
fois.
Avec un do/while cette astuce est inutile. On peut en effet écrire :

int nombre;
do {
System.out.print("Entrez une valeur comprise entre 3 et 11 :");
nombre = Clavier.lireInt();
} while ((nombre <3 || nombre >11));
System.out.println("Enfin…");

L’instruction break permet de sortir d’une boucle while, do/while ou for. L’instruction
continue permet de passer immédiatement à l’itération suivante.

for(int i=0; i <=100;i++) {


char c = Clavier.lireChar();
if (c=='Q') break ;
if (c=='C') continue;
System.out.println("Car : " + c);
}

Marc Tizzano (EMN) 63


INFO09EXE02

Ecrire un programme qui lit un caractère au clavier et qui le transforme en majuscule, qui
l'affiche et qui sort quand l'utilisateur a tapé 'Q'.
Ne pas utiliser de break.

INFO09EXE03

Les commentaires itérés1


On part d’un nombre 1 par exemple. Puis on le lit, cela donne "un 1” et cela s’écrit "11".
On lit alors ce nouveau nombre et sans hésiter on le lit "deux 1"que l’on écrit "21". On
continue ainsi et l’on obtient "1211"puis “111221"etc. Ecrivez un programme qui
reproduit cette suite.

1
Cet exercice est lui aussi adapté d’un article de Jean-Paul Delahaye dans « Jeux mathématiques et
mathématiques des jeux »

Marc Tizzano (EMN) 64