précédent | suivant | table des matières s'évaluer

Instructions

Sommaire
  1. Instruction bloc
  2. Instructions conditionnelles
  3. Instruction switch
  4. Itérations
    1. while
    2. do
    3. for
  5. Exemples
  6. for du jdk1.5
  7. Etiquettes

1 Instruction bloc

Les accolades jouent avec les instructions le même rôle que les parenthèses avec les expressions : elles permettent de faire d’une séquence d’instructions séparées par des ; une seule instruction. On attachera un soin particulier à l’indentation des instructions mises entre accolades : 

{    
    I1 ;    
    I2 ;
    . . .
    In ;

}
 La liste d’instructions peut être vide.
L'exécution d'une instruction bloc, c'est l'exécution en séquence des instructions composant l'instruction bloc.
Une variable déclarée dans un bloc a une portée qui va jusqu'à la fin du bloc : elle est connue depuis sa déclaration, jusqu'à l'accolade fermante.

2 Instructions if

Il existe 2 formes de l’instruction conditionnelle :

if( expression booléenne ) instruction I1 ;
L’exécution de l’instruction commence par l’évaluation de l’expression booléenne : si celle-ci a valeur true, alors il y a exécution de l’instruction I1.

 
if( expression booléenne ) instruction I1 ;
else instructionI2 ;
 L’exécution de l’instruction commence par l’évaluation de l’expression booléenne : si celle-ci a valeur true, alors il y a exécution de l’instruction I1 sinon il y a exécution de l’instruction I2.

Les instructions I1 ou I2 peuvent être l’instruction vide.


3 Instruction switch

L’instruction switch se construit de la façon suivante : 

switch( expression entière ou caractère ){
   case v1 : instructions I1;
   case v2 : instructions I2;
   ...
   default : instructions In;
}

L’exécution de l’instruction commence par l’évaluation de l’expression entière, soit v cette valeur : Puis on recherche la première valeur vi égale à v : on commence alors l’exécution des instructions qui suivent la valeur vi. Si cette valeur n’est pas trouvée, ce sont les instructions In qui sont exécutées.

En général après l’exécution de I1, on ne désire pas exécuter I2, etc … Alors la structure du switch sera plutôt : 

switch( expression entière ou caractère ){
   case v1 : instructions I1; break;
   case v2 : instructions I2; break;
   ...
   default : instructions In;
}

Les instructions I1, I2 ou In peuvent être l’instruction vide.

4 Itérations

Les instructions d'itération sont des instructions qui permettent de répéter l'exécution d'une (ou plusieurs) instruction(s) zéro, une ou plusieurs fois.

4.1 while

Le tantque se construit de la façon suivante : 

while( expression booléenne ) Instruction ;

On évalue d’abord l’expression booléenne : 

  1. si celle-ci a la valeur true, on exécute l’instruction puis on re-exécute le tantque
  2. si celle-ci a la valeur false l’exécution du tantque est terminée
L’instruction   peut être l’instruction vide.

4.2 do

Le do se construit de la façon suivante : 

do{
   instructions
}while( expression booléenne);

On exécute d’abord les instructions, puis on  évalue l’expression booléenne : 

  1. si celle-ci a la valeur true, on re-exécute le do
  2. si celle-ci a la valeur false l’exécution du do est terminée

La liste d’instructions   peut être l’instruction vide.

4.3 for

Le for se construit de la façon suivante : 

for(initialisations ; expression booléenne ; mises à jour) instructions ;
  1. On exécute d’abord les initialisations
  2. Puis on  évalue l’expression booléenne : 

Les initialisations et les mises à jour sont séparées par des virgules.

La liste d’instructions peut être l’instruction vide.

Les instructions dépendant des itérations for, while,ou do peuvent contenir des instructions : 

Les instructions Java peuvent être étiquetées, alors les break, ou continue inclus dans une instruction étiquetée peuvent faire référence à cette étiquette : 

5 Exemple :

Nous nous proposons de calculer la somme des n premiers entiers, pour n>=0 : 

  while   
int n = 10;
int somme = 0;
int i;
i = 1;
while( i<=n){
   somme = somme + i;
   i = i+1;
}
System.out.println(" la somme des "+n+" premiers entiers est : "+somme);
  for   
int n = 10;
int somme = 0;
int i;
for( i=1; i<=n; ++i)
   somme = somme + i;
System.out.println(" la somme des "+n+" premiers entiers est : "+somme);
  do   
int n = 10;
int somme = 0;
int i=0;
do{
   somme = somme + i;
   ++i;
}while(i<=n);
System.out.println(" la somme des "+n+" premiers entiers est : "+somme);

6 for : le nouveau for du JDK 1.5 :

for(Paramètre formel : expression) instruction;

L'expression doit être un tableau ou  une instance de classe implémentant l'interface Iterable : L'interface java.util.collection étend depuis le JDK1.5 l'interface Iterable.

Exemples :

  1. int [] t = {1, 2, 3, 4, 5, 6};
for( int a : t) System.out.println(a);
    L'instruction suivante ne modifie pas le tableau t.
    for( int a : t)++a;
  2. Liste l = new ArrayList();
for( int a : l) System.out.println(a);

7 Les étiquettes

En Java toute instruction (pas les déclarations) peut être étiquettée. Une étiquette est un identificateur Java suivi de :

Exemple

int a = 0;
etiq1 : if(true);
etiq2 : switch(1){
   //  ...
}
etiq3 : a=1;
etiq4 : a++;
etiq5 : {
   //  ...
}
etiq6 : for(; ; ) break;
etiq7 : while( true ) break;

L'utilisation à tort et à travers des étiquettes permet d'écrire des programmes illisibles. La seule utilisation qui peut être intéressante est de pouvoir arrêter une itération englobant une autre itération depuis l'intérieur de cette dernière :


etiq1 : while(true){

   while(...){
   
      if(...) break etiq1; //  Arrête l'itération étiquettée par etiq1
   
    }
    
}

haut de la page