next up previous contents index
Next: 6 Classes et Objets Up: Java: Le langage Previous: 4 Opérations et expressions

Subsections

5 Les structures de contrôle

   

5.1 Instructions et blocs

   

Un programme (voir 5.6) Java est constitué de déclarations de classes dans lesquelles figurent des méthodes. Les méthodes sont construites à l'aide d'instructions combinées entre elles avec des structures de contrôles . Tout d'abord qu'entend-on par instruction ? Une expression telle que x=0, i++ ou printf("coucou\n") sont des instructions lorsqu'elles sont suivies du caractère point virgule (``;'').

 
x=0 ;
i++ ;
printf("coucou\n") ;
Le point virgule est appelé terminateur d'instruction. Même si n'importe quelle expression peut être utilisée par écrire une instruction, les instructions intéressantes sont celles qui provoquent un effet de bord i.e. qui permettent, outre le fait d'évaluer cette expression, de modifier l'état du système. C'est le cas de l'affectation qui modifie le contenu de l'opérande gauche.

Les instructions composées ou blocs sont des suites d'instructions simples ou composées regroupées à l'aide des accolades ``{'' et ``}''. L'accolade fermante n'est pas suivie d'un point virgule.

 
int i ;
i = 32 ;
printf("coucou\n") ;

5.2 Instruction conditionnelle (if)

     

Cette instruction conditionnelle permet d'exécuter des instructions de manière sélective en fonction du résultat d'un test. La syntaxe de l'instruction est :

 
if (expression)  instruction1
if (expression) instruction1 else instruction2
Si l'expression est vraie, l'instruction1 s'exécute ; sinon, dans le deuxième cas, c'est l'instruction2 qui s'exécute. Rappelons que, contrairement au langage C, une valeur booléenne n'est pas un entier. En particulier, la fameuse erreur, que tout le monde a au moins fait une fois dans sa vie de programmeur C, et qui sont si difficile à trouver, du style
 
if (x = 2) ...         au lieu de       if (x == 2) ...

ne peuvent plus se produire en Java. De plus, les instructions suivantes ne plus équivalentes :

 
if (expression) ...    et      if (expression != 0) ...
D'après la syntaxe de l'instruction if, la partie else est facultative ; il en découle une ambiguïté lorsqu'il y a des instructions if imbriquées. Dans l'exemple suivant, comme le suggère l'indentation du programme
 
if (condition1)
    if (condition2)
        instruction1
    else
        instruction2
L'instruction2 correspond au else de l'expression2. L'écriture suivante est strictement identique à la première.
 
if (condition1)
    if (condition2)
        instruction1
else
    instruction2
Visiblement, le programmeur veut faire correspondre l'instruction2 au else de l'expression1. Comment faire ? Il suffit de transformer l'instruction imbriquée en un bloc d'instruction(s) de la manière suivante :
 
if (condition1)  {
    if (condition2)
        instruction1
    }
else
    instruction2
Voici une construction, que l'on rencontre fréquemment, qui permet de faire une étude de cas :
 
if (condition1)
    instruction1
else if (condition2)
    instruction2
else if (condition3)
    instruction3
else
    instruction4
Cette instruction effectue successivement chacun des tests et aucun des tests n'est vraie, l'instruction4 sera exécutée (instruction par défaut).

5.3 Etude de cas (switch)

          On dispose d'une instruction pour faire une étude de cas : c'est l'instruction switch.
 
switch (expression)  {
    case constante1 :
        instruction1
    case constante2 :
        instruction2
    ...
    case constanteN :
        instructionN
    default :
        instruction
}
Si la valeur de expression vaut constantei , on exécute la suite des instructions commençant à instructioni . Attention, cette instruction ne se contente pas d'exécuter les instructions comprises entre instructioni et instructioni + 1 ; elle exécute toutes les instructions instructioni ainsi que toutes celles qui suivent instructioni jusqu'à la rencontre de l'instruction break ou de la fin de l'instruction switch.

Lorsque la valeur de l'expression est égale à aucune des constantes mentionnées, ce sont les instructions étiquetées par default qui seront exécutées.

Exemple.


 
    char c ;
    ...
    switch(c) {
        case '1' :
        case '2' :                                  // notez l'absence d'instruction ici
        case '3' :
        case '5' :
        case '7' :
            System.out.println("%c est un nombre premier\n", c) ;
            break ;                                 // notez l'instruction break
        case '6' :
            System.out.println ("%c est un multiple de 3\n", c) ;
                                                    // notez l'absence d'instruction break
        case '4' :
        case '8' :
            System.out.println ("%c est un multiple de 2\n", c) ;
            break ;
        case '9' :
            System.out.println ("%c est un multiple de 3\n", c) ;
            break ;
        default :                                   // instruction par défaut
            System.out.println ("%c n'est pas un chiffre\n", c) ;
        }
...
Dans le programme ci-dessus, on a regroupé les cas 1, 2, 3, 5 et 7 pour n'écrire qu'une seule fois l'instruction d'affichage. L'instruction break arrête l'exécution de ce switch. Le chiffre 6 est à la fois un multiple de 2 et de 3. On factorise une partie de l'affichage avec les cas 4 et 8 ; d'où l'absence de l'instruction break.

5.4 Itérations

  Les instructions itératives ou boucles sont réalisées à l'aide d'une des trois structures de contrôle suivantes :
 
while (condition)
    instruction

do
    instruction
while (condition) ;

for (expression1 ; condition2 ; expression3)
    instruction

5.4.1 Instruction while

  La structure de contrôle while évalue la condition et exécute l'instruction tant que cette condition est vraie. Le programme suivant affiche à l'écran (dans l'ordre) tous les nombres de 10 à 0.
 
x = 10 ;
while (x >= 0) {                     // tant que x est positif ou nul
   printf("%d", x) ;                 // imprimer x
    x = x -1 ;                       // décrémenter x
}

Autre version de ce même programme

 
x = 10 ;
while (x >= 0)                       // tant que x est positif
    printf("%d", x--) ;              // imprimer et décrémenter x

5.4.2 Instruction do ... while

  Une variante de cette instruction while est l'instruction do ... while. Contrairement à l'instruction while, l'instruction
 
do
    instruction
while (condition) ;
est exécutée au moins une fois. L'itération s'arrête lorsque l'expression est fausse. Pour les habitués du langage Pascal , cette instruction n'est pas l'équivalent de l'instruction repeat ... until.

5.4.3 Instruction for

  L'instruction for, comme l'instruction while, n'exécute l'instruction que si la condition2 est vraie.
 
for (expression1 ;                         // Initialisation
    condition2 ;                           // Conditions d'arrêt
       expression3)                        // Fin du corps de boucle
    instruction
Cette instruction qui est composée de trois parties séparées par des point virgules : expression1 constitue les initialisations nécessaires avant l'entrée dans la boucle. condition2 constitue la ou les conditions de boucle et expression3 constitue les instructions de fin de boucle. L'instruction for
 
for (expression1 ; condition2 ; expression3)
   instruction
peut se traduire avec l'instruction while de la manière suivante :
 
expression1 ;
while (condition2) {
    instruction
    expression3 ;
}
Les parties expression1, condition2 et expression3 peuvent être éventuellement être vides. Par exemple, on effectue une boucle infinie avec l'instruction
 
for ( ; ; )
    instruction
L'opérateur virgule " , " est généralement utilisé pour combiner plusieurs initialisations et plusieurs instructions de fin du corps de boucle.

14.14.3 Exemple


 
for (i=1, j=10 ; i < j ; i++, j--) {
        ...
}

5.5 Etiquette, break, continue et return

       

5.5.1 Les étiquettes

Comme tous les langages, n'importe quelle instruction peut être étiqutées. La syntaxe d'une étiquette est
 
etiquette :     instruction

5.5.2 L'instruction break

L'instruction break que l'on a déjà vu lors de la description de l'instruction switch. En fait, l'instruction break est utilisée dans les structures de contrôle : switch, while, do ... while et for. Dans une boucle, cette instruction provoque la sortie immédiate de la boucle sans tenir compte des conditions d'arrêt de la boucle.

Une variante de l'instruction break permet de lui associer une étiquette.

 
etiquette :
while (...) {
    ...
    break etiquette ;
    ...
}

5.5.3 L'instruction continue

Dans une structure de contrôle while, do ... while et for, l'instruction continue produit l'abandon de l'itération courante et, si le condition d'arrêt l'autorise, le démarrage de l'itération suivante.

5.5.4 L'instruction return

L'instruction return ou return expression provoque l'abandon de la fonction en cours et le retour à la fonction appelante. Le résultat est la valeur que la fonction appelée renvoie à la fonction appelante. Comme dans le cas des passage d'arguments d'une fonction, la valeur retournée par la fonction subit les conversions habituelles. Lorsque la fonction ne retourne aucune valeur (cas d'une procédure), on utilisera l'instruction return sans argument.

5.5.5 Quid ? Point de goto ?

Eh bien non, pas de goto ; et on s'en passe très bien avec d'une part les break étiquetés et d'autre part le bloc de code finally.

5.6 Structure d'un programme autonome Java

    Un programme Java est constitué d'une ou de plusieurs classes. Parmi toutes ces classes, il doit exister au moins une classe qui contient la méthode statique et publique main qui est le point d'entrée de l'exécution du programme. Comme d'habitude, commençant une tout petit exemple :
 
// Fichier Bonjour.java
public class Bonjour {
    public static void main(String args[]) {
        System.out.println("Bonjour ! ") ;
}
Cette classe définit une classe Bonjour qui ne possède qu'une seule méthode. La méthode main doit être déclarée static et public pour qu'elle puisse être invoquée par l'interpréteur Java. L'argument args est un tableau de String qui correspond aux arguments de la ligne de commande lors du lancement du programme.

Avant de pouvoir exécuter ce programme, il faut tout d'abord le compiler avec la commande javac.

 
javac Bonjour.java
La commande javac traduit le code source en code intermédiaire java. Ce code est évidemment indépendant de la plate forme sur laquelle il a été compilé. Le compilateur Java produit alors autant de fichiers que classes qui ont été définies dans le fichier source. Les fichiers compilés ont l'extension .class.

Enfin, pour exécuter ce programme, il faut utiliser l'interpréteur de code Java et lui fournir le nom de la classe public que l'on veut utiliser comme point de départ de notre programme.

 
java Bonjour


next up previous contents index
Next: 6 Classes et Objets Up: Java: Le langage Previous: 4 Opérations et expressions
Touraivane
6/12/1998