Next: 6 Classes et Objets
Up: Java: Le langage
Previous: 4 Opérations et expressions
Subsections
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") ;
|
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).
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.
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.
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
|
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
|
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.
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
L'opérateur virgule " , " est généralement utilisé pour combiner
plusieurs initialisations et plusieurs instructions de fin du
corps de boucle.
for (i=1, j=10 ; i < j ; i++, j--) {
...
}
|
Comme tous les langages, n'importe quelle instruction peut être
étiqutées. La syntaxe d'une étiquette est
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 ;
...
}
|
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.
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.
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.
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.
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.
Next: 6 Classes et Objets
Up: Java: Le langage
Previous: 4 Opérations et expressions
Touraivane
6/12/1998