CHAPITRE 5 : LES INSTRUCTIONS DE

CONTROLE DE JAVA

A priori, dans un programme, les instructions sont exécutées séquentiellement, c’est-à-dire

dans l’ordre où elles apparaissent. Or la puissance et le comportement intelligent d’un
programme proviennent essentiellement de la possibilité de s’affranchir de cet ordre pour
effectuer des choix et des boucles (répétitions). Tous les langages disposent d’instructions,
nommées instructions de contrôle, permettant de les réaliser. Elles peuvent être :
• Fondées essentiellement sur la notion de branchement (conditionnel ou inconditionnel)
; c’était le cas, par exemple, des premiers Basic ;
• Ou, au contraire, traduire fidèlement les structures fondamentales de la programmation
structurée ; c’est le cas, par exemple, du langage Pascal bien que, en toute rigueur, ce
dernier dispose d’une instruction de branchement inconditionnel GOTO.
Java (comme C) est assez proche du Pascal sur ce point puisqu’il dispose d’instructions
structurées permettant de réaliser :
• Des choix : instructions if...else et switch,
• Des boucles (répétitions) : instructions do... while, while et for.
Toutefois, la notion de branchement n’est pas totalement absente de Java puisque, comme
nous le verrons :
• Il dispose d’instructions de branchement inconditionnel : break et continue,
l’instruction de choix multiple que constitue switch est en fait intermédiaire entre le
choix multiple parfaitement structuré du Pascal et l’aiguillage multiple du Fortran.
Ce sont ces différentes instructions de contrôle de Java que nous nous proposons d’étudier
dans ce chapitre.

1. L’instruction IF
Le mot else et l’instruction qu’il introduit étant facultatifs, l’instruction if présente deux
formes :

if (condition) {
bloc d'instructions 1;
}
else {
bloc d'instructions 2;
}

Condition : est une expression booléenne quelconque,

Instruction_1 et instruction_2 : sont des instructions quelconques, c’est-à-dire :
– simple (terminée par un point-virgule),
– structurée,
– bloc.
N.B. : les crochets [...] signifient que ce qu’ils renferment est facultatif.

Imbrication des IF

if (condition 1) {
bloc1;
}
else if (condition 2) {
bloc2;
}
else if (condition 3) {
bloc3;
}
else {
bloc4;
}

Nous avons déjà mentionné que les instructions figurant dans chaque partie du choix d’une
instruction pouvaient être absolument quelconques. Elles peuvent en particulier renfermer à
leur tour d’autres instructions if. Compte tenu des deux formes possibles de l’instruction if
(avec ou sans else), il existe certaines situations où une ambiguïté apparaît.
Voici un exemple d’utilisation de if imbriqués. Il s’agit d’un programme de facturation avec
remise. Il lit en donnée un simple prix hors taxes et calcule le prix TTC correspondant (avec
un taux de TVA constant de 18,6%). Il établit ensuite une remise dont le taux dépend de la
valeur ainsi obtenue, à savoir :
• 0 % pour un montant inférieur à 1 000 F,
• 1 % pour un montant supérieur ou égal à 1 000 F et inférieur à 2 000 F,
• 3 % pour un montant supérieur ou égal à 2 000 F et inférieur à 5 000 F,
• 5 % pour un montant supérieur ou égal à 5 000 F.
Ce programme est accompagné de deux exemples d’exécution.
public class Tva
{ public static void main (String[] args)
{ double taux_tva = 21.6 ;
double ht, ttc, net, tauxr, remise ;
System.out.print ("donnez le prix hors taxes : ") ;
ht = Clavier.lireDouble() ;
 ttc = ht * ( 1. + taux_tva/100.) ;
if ( ttc < 1000.) tauxr = 0 ;
else if ( ttc < 2000 ) tauxr = 1. ;
else if ( ttc < 5000 ) tauxr = 3. ;
else tauxr = 5. ;
remise = ttc * tauxr / 100. ;
net = ttc - remise ;
System.out.println ("prix ttc " + ttc) ;
System.out.println ("remise " + remise) ;
System.out.println ("net à payer " + net) ;
}
}

Résultat :

Donnez le prix hors taxes

Prix ttc 4864.0
Remise 145.92
Net à payer 4718.08

Donnez le prix hors taxes : 859.45

Prix ttc 1045.0912
Remise 10.450912
Net à payer 1034.640288

2. L’instruction SWITCH
L'instruction switch permet de s'affranchir des branchements else if vu précédemment, dans le
cas où les conditions sont toujours des tests d'égalité sur la même variable. Une
grosse contrainte porte sur le paramètre de l'instruction switch : il doit être obligatoirement
de type entier. On peut donc uniquement utiliser le switch pour comparer des valeurs entières
entre elles.
public class Switchgen{
public static void main (String[] args){
int n ;
System.out.print ("donnez un nombre entier : ") ;
n = Clavier.lireInt() ;
 switch (n) {
case 0 : System.out.println ("nul") ;
break ;
case 1 :
case 2 : System.out.println ("petit") ;
case 3 :
case 4 :
case 5 : System.out.println ("moyen") ;
break ;
default : System.out.println ("grand") ;
}
System.out.println ("Au revoir") ;
}
}
Résultat :
………
Syntaxe de l’instruction switch

switch (expression){
case 1 : [ suite_d’instructions_1 ]
case 2 : [ suite_d’instructions_2 ]
..............
case n : [ suite_d’instructions_n ]
default : [ suite_d’instructions ]
}

Le fonctionnement est le suivant. Toutes les conditions sont testées, et toutes celles qui sont
vraies voient leur bloc d'instructions exécuté. Si on souhaite, que seul le bloc correspondant à
la condition vérifiée ou à la première condition vérifiée soit exécuté, il faut terminer chaque
bloc par l'instruction break comme ceci :

case 1: {
bloc1;
break;
}
 3. L’instruction do... while
L'instruction do...while correspond au "repeat" des autres langages. Il correspond au cas où
le traitement doit s'éffectuer au moins une fois et lorsque c'est lui qui détermine l'état de la
condition. La syntaxe est la suivante :

do {
instruction1;
instruction2;
...
instructionn;
}
while (condition);

Instruction est une instruction quelconque,

Condition est une expression booléenne quelconque.
Exemple :
public class Do1
{ public static void main (String args[])
{ int n ;
do
{ System.out.print ("donnez un nombre >0 : ") ;
n = Clavier.lireInt() ;
System.out.println ("vous avez fourni " + n) ;
}
while (n <= 0) ;
System.out.println ("reponse correcte") ;
}
}
Résultat :
Donnez un nombre >0 : -4
Vous avez fourni -4
Donnez un nombre >0 : -5
Vous avez fourni -5
Donnez un nombre >0 : 14
Vous avez fourni 14
Réponse correcte

4. L’instruction while
L'instruction while permet d'itérer un bloc d'instructions tant qu'une condition est vérifiée.
Elle présente de plus l'avantage de tester la condition avant la première exécution. La syntaxe
est la suivante :

while (condition) { Par exemple 1 :

instruction 1; int x = 0;
instruction 2; while (x < 10) {
... System.out.println(x) ;
Instruction n; i++;
} }

Exemple 2 :
public class While1
{ public static void main (String args[])
{ int n, som ;
som = 0 ;
while (som < 100)
{ System.out.print ("donnez un nombre : ") ;
n = Clavier.lireInt() ;
som += n ;
}
System.out.println ("Somme obtenue : " + som) ;
}
}
Résultat :
Donnez un nombre : 15
Donnez un nombre : 27
Donnez un nombre : 14
Donnez un nombre : 56
Somme obtenue : 112
 5. L’instruction For
La boucle for est utilisée pour répéter un traitement sous forme de bloc d'instructions un
certain nombre de fois en principe connu à l'avance. La syntaxe est la suivante.

for (initialisation; test; Par exemple :

incrémentation) {
int i = 0;
bloc;
for (i = 2; i < 10; i++) {
} System.out.println("Coucou") ;
}

On peut bien évidemment imbriquer plusieurs boucles for entre elles :

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

for (int j = 0; j < 10; j++) {
tableau[i][j] = i*j;
}
}

Exemple 1 :
public class For1
{ public static void main (String args[])
{ int i ;
for (i=1 ; i<=5 ; i++)
{ System.out.print ("bonjour ") ;
System.out.println (i + " fois") ;
}
}
}
Exemple 2 :
public class For2
{ public static void main (String args[])
{ int i = 1 ;
i=1;
while (i <= 5)
{ System.out.print ("bonjour ") ;
System.out.println (i + " fois") ;
i++ ;
}
}
}

Exemple 3 :
public class For3
{ public static void main (String args[])
{ int i, j ;
for (i=1 , j=3 ; i<=5 ; i++, j+=i)
{ System.out.println ("i = " + i + " j = " + j) ;
}
}
}
Résultat :
i=1j=3
i=2j=5
i=3j=8