|
Les instructions du langage
Dans le chapitre précédent, nous avons vu ce qu'étaient les expressions : celles-ci permettent de calculer des valeurs. Parallèlement, nous avons les instructions qui permettent de lancer des actions. En composant les instructions, on définit ainsi le comportement que le programme devra adopter. Pour mieux comprendre les choses, nous allons, tout au long de ce chapitre, étudier une à une, toutes les instructions utilisable en Java. Ceux d'entre vous qui connaissent C, C++ ou bien encore Javascript, si retrouverons assez facilement (les syntaxes restantes très proche les unes des autres). Pour les autres, il est temps d'apprendre à utiliser ces instructions.
Syntaxiquement parlant, toute instruction se finie par un point-virgule (histoire de bien séparer les choses), et ce même si l'instruction est en dernière position d'une construction. Notons tout de suite qu'une expression peut être une instruction (si elle est suivie d'un point-virgule). Il est donc tout a fait possible d'avoir comme instruction "a+b;" et heureusement, car n'oublions pas que l'affectation se fait grâce à des opérateurs. Il aurait été dommage de ne pas pouvoir écrire "
a=3;" dans un coin d'un programme.
Les blocs d'instructions
Comme nous allons le voir plus loin dans ce chapitre, il peut-être utile, selon les situations, de placer plusieurs instructions à un endroit précis. Or certaines constructions (instructions), n'accepte qu'une seule sous-instruction (comme, par exemple, pour le if). Pour palier à ce problème, une solution agréable à était utilisée (en fait, héritée de C) : on définit un bloc d'instruction comme étant une instruction.
Au point de vue de la syntaxe, un bloc d'instructions commence par une accolade ouvrante et se termine par une accolade fermante. Entre ces deux caractères, nous y trouvons les sous-instructions, qui sont séparées les unes des autres par des points-virgules. Attention : la dernière instruction d'un bloc doit se terminer, elle aussi, par un point-virgule. Le bloc peut contenir zéro (bloc vide), une (équivalent à une instruction unique) ou plusieurs sous-instructions.
Fichier "Essai.java"
public class Essai {
static public void main(String argv[]) {
{ // Un nouveau bloc, lui même dans un bloc
System.out.println("Un");
System.out.println("Deux");
System.out.println("Trois");
}
System.out.println("Exit");
}
}
L'instruction conditionnelle if
Syntaxiquement parlant, l'instruction conditionnelle s'introduit avec le mot clé if (attention, majuscules et minuscules sont différentes en Java : IF ou If ou bien encore iF sont des identificateurs différents). Il faut faire suivre cet identificateur d'un test (une expression booléenne) parenthésée, puis d'une instruction. Cette dernière sera exécutée uniquement si la valeur du test est vraie (true). Si ce n'est pas le cas, il est possible de rajouter le mot clé else suivi d'une instruction qui sera alors lancée. Le tableau suivant vous donne la syntaxe complète : notez que ce qui est facultatif est noté entre crochets.
Fichier "Essai.java"
public class Essai {
static public void main(String argv[]) {
// On récupère le nombres de paramètres
// saisis sur la ligne de commande
int l = argv.length;
if (l != 1) {
System.out.println("Entrez un paramètre");
System.exit(-1);
}
else System.out.println(argv[1]);
}
}
Notez bien que la partie associée à un résultat faux, est facultative. Autre détail important, même si votre test se réduit en la valeur d'une variable déclarée comme booléenne, il est obligatoire de la parenthéser. Rien de supplémentaire est à ajouter sur cette instruction.
Les instructions liées aux boucles
Comme nous allons maintenant le voir, il existe quelques instructions qui nous permettent de mettre en place des boucles (ou des itérations, c'est la même chose) et d'en contrôler leurs exécutions. Trois styles de boucles sont utilisables, et deux instructions permettent de débrancher l'exécution à l'intérieur d'une boucle.
Étudions cela de plus près
La boucle for
Cette deuxième instruction permet de définir ce que l'on appelle des boucles. Pour un peu mieux comprendre les choses, je vais tenter de vous expliquer ce qu'est une boucle en informatique. Certaines actions nécessite un traitement dit itératif (c'est à dire répétitif) : une même action doit être appliquée jusqu'à obtention d'une condition d'arrêt (on ne voudrais pas que le traitement soit de durée infinie). Pour imager le concept, imaginons une personne sur une chaîne de fabrication qui attends désespérément l'heure de rentrer chez elle. De manière analogue, un programme peut avoir besoin d'effectuer une itération sur un traitement, et comme le programme doit se terminer, il nous faut matérialiser un cas d'arrêt. L'instruction
for permet de réaliser cela très simplement. D'autres instructions permettent aussi de créer des boucles, nous les verrons après.
Pour en revenir au for, son utilisation est vraiment très simple. Vous introduisez l'instruction par le mot clé
for, puis vous devez fournir trois expressions (elles seront toutes les trois séparées les unes des autres par des points-virgules, et mises entre parenthèses) suivies d'une instruction qui constituera le traitement à répéter. Pour ce qui est des trois expressions, pas de panique : c'est vraiment simple. Elles servent à manipuler des variables qui vont être utiles pour la boucle. La première sert à initialiser ces variables. Pour ceux qui se demandent comment initialiser trois variables avec une expression, rappelez vous que l'on a la possibilité de construire une expression à partir de sous expressions grâce au séparateur d'expressions. La deuxième permet de déterminer la condition de rebouclage à partir de l'état des variables utilisées : si cette condition n'est pas réalisée, on stop l'itération. Enfin, la dernière sert à modifier l'état des variables après chaque itérations.
Fichier "Essai.java"
public class Essai {
static public void main(String argv[]) {
// On veut réaliser 10 affichages
for(int i=0;i<10;i++) System.out.println("i vaut : " + i);
}
}
Remarquez que le dernier exemple sert à définir une boucle infinie : cela peut être utile dans certains cas très particuliers. Autre remarque devant être signalée, la deuxième expression est forcément de type booléenne, la valeur
false assurant la sortie de la boucle. A titre d'exemple, voici un petit programme qui calcul la somme des dix premiers entiers positifs et l'affiche. Certes on aurait put mettre que somme valait 1+2+3+4+5+6+7+8+8+9+10, mais imaginez vous l'expression que vous auriez du donner si j'avais demandé la somme des dix mille premiers entiers. Une boucle est alors la seule alternative sérieuse.
Fichier "TenCounter.java"
public class TenCounter {
public static void main(String argv[]){
int somme=0;
for(int indice=1;indice<=10;indice++) somme += indice;
String str = "La somme des dix premiers entiers positifs est : ";
System.out.println(str + somme);
}
}
La boucle while
Cette instruction permet elle aussi de définir des boucles, mais la syntaxe diffère. Pour ceux qui se demandent pourquoi avoir plusieurs constructions possibles pour les boucles, je répondrais que selon les cas il y en a qui sont plus adaptées que les autres. La syntaxe du
while est la suivante : l'instruction commence par le mot clé
while suivie d'une expression booléenne parenthésée et d'une instruction. L'expression sert à déterminer s'il faut encore effectuer une itération, ou bien passer à l'instruction suivant la boucle. L'instruction de la boucle, elle est exécutée à chaque étape de la boucle. Pour mieux voir les choses, reprenons l'exemple précédent (la somme des dix premiers entiers positifs), et réécrivons le avec le
while. En voici le code.
Fichier "TenCounter.java"
public class TenCounter {
public static void main(String argv[]){
int somme=0, indice=1;
while(indice<=10) somme += indice++;
String str = "La somme des dix premiers entiers positifs est : ";
System.out.println(str + somme);
}
}
Dans tout les cas, on retrouve l'initialisation de la variable indice, mais elle est située en dehors de la boucle, on retrouve aussi l'incrémentation, mais celle-ci est maintenant placée dans la partie des choses à faire à chaque tour de boucle. Le résultat lui reste strictement le même.
La boucle do while
Cette instruction a un fonctionnement quasi identique à la précédente. La différence essentielle réside dans le fait que l'on commence par calculer l'expression correspondante au test ou bien que l'on commence à exécuter l'instruction. Au point de vue de la syntaxe, on introduit l'instruction par le mot clé
do que l'on fait suivre d'une instruction (le corps de la boucle, qui sera la première chose qui sera lancée), puis du mot clé
while, lui même suivit d'une expression parenthésée. Cette dernière constitue la condition de rebouclage (la valeur
false assurant la fin de la boucle). A titre d'exemple voici encore un programme calculant la somme des dix premiers entiers positifs.
Fichier "TenCounter.java"
public class TenCounter {
public static void main(String argv[]){
int somme=0, indice=1;
do somme+=indice++;
while(indice<=10);
String str = "La somme des dix premiers entiers positifs est : ";
System.out.println(str + somme);
}
}
Nous en avons maintenant finit des instructions de boucles. Cependant, deux autres instructions sont tout de même très pratiques pour contrôler ce qui se passe durant l'exécution d'une boucle. Il s'agit de
continue et de break dont une petite description suit.
L'instruction continue
L'instruction continue permet d'arrêter le traitement pour l'itération en cours, et d'en recommencer immédiatement une nouvelle. Passons tout de suite à un exemple, histoire de mieux comprendre les choses. Supposons que l'on ait besoin de calculer la somme des dix premiers entiers positifs, excepté pour l'entier 5. Un code Java possible est alors ...
Fichier "TenCounterMinusFive.java"
public class TenCounterMinusFive {
public static void main(String argv[]){
int somme=0, indice=1;
while(indice<11)
if (indice==5) { indice++; continue; }
else somme += indice++;
String str = "La somme des dix premiers entiers positifs (privé de 5) est : ";
System.out.println(str + somme);
}
}
Si vous exécutez ce code, le résultat affiché vaudra 50 (soit 55 moins la valeur du cinquième entier, soit 5). Il faut bien comprendre deux choses. Premièrement, quoi que l'on puisse mettre après le
continue, ce code ne sera pas exécuté. Deuxièmement, un continue doit forcément être placé dans une branche d'un test conditionnel, sans quoi ca n'a pas de sens. Pour mieux comprendre ce dernier point, méditez sur le bout de programme suivant.
while(a<1000) {
a++;
continue;
// Tout le code qui suit ne sera JAMAIS exécuté.
// Alors pourquoi l'avoir mit ?? Il est donc clair que ce
// programme n'est pas au point.
b = a+2;
}
On peut encore faire plus compliqué avec cette instruction. Elle peut permettre de reprendre l'exécution en un point précis du programme. De tels points d'un programme sont nommés des labels (ou étiquettes). Au point de vue de la syntaxe, on définit un label par un identificateur immédiatement suivit d'un deux-points (par exemple, labelName:). Le programme suivant à pour but de mieux vous faire comprendre ce qui se passe (un exemple d'exécution y est joint).
Fichier "Continue.java"
public class Continue {
public static void main(String argv[]){
int a, b=0, s=0;
while(b<5) {
a=0; b++;
while(a<5) {
a++;
if (a==3) continue;
else s++;
}
}
System.out.println("Somme calculée avec \"continue;\" : " + s);
b=s=0;
label1: while(b<5) {
a=0; b++;
while(a<5) {
a++;
if (a==3) continue label1;
else s++;
}
}
System.out.println("Somme calculée avec \"continue label1:\" : " +s);
}
}
Résultats
> javac Continue.java
> java Continue
Somme caculée avec "continue;" : 20
Somme caculée avec "continue label1;" : 10
>
Le résultat obtenu etait tout à fait prévisible. En effet, dans le premier cas, on esquive seulement cinq incrémentations de la variable s. Dans le second bloc de boucles, les choses se compliquent, car dés lors que a vaut 3, on esquive toutes les incrémentations suivantes pour l'itération sur b en cours. Du coup, le résultat en est sévèrement altéré. Il existe une autre instruction qui permet d'effectuer un débranchement au sein des boucles en voici une brève présentation.
L'instruction break
Cette instruction permet donc aussi de faire un débranchement au sein d'une boucle, mais contrairement à l'instruction précédente, l'exécution se poursuit non pas par une nouvelle itération, mais par l'instruction suivant la boucle. Elle sert donc purement et simplement à stopper la boucle de façon définitive. Le programme suivant illustre mes propos.
Fichier "Break.java"
public class Break {
public static void main(String argv[]){
int somme=0, indice=1;
while(indice<=10) {
if (indice==5) break;
somme += indice++;
}
System.out.println("Le résultat vaut : "+somme);
}
}
Le résultat vaut bien évidement 10. Dernière remarque au sujet de cette instruction : on peut aussi interrompre une boucle et reprendre au label spécifié (de même que l'instruction continue).
L'instruction switch
Pour conclure ce chapitre, nous allons voir comment utiliser l'instruction
switch. Celle-ci permet de choisir une séries d'instructions à exécuter parmi différentes séries. La sélection s'effectue grâce à la valeur d'une variable. Cette variable doit au préalable avoir été déclaré d'un type énumérable (byte, short, int, long). Notez, toute fois, qu'une valeur de type
boolean, bien que répondant au critère demandé, n'est pas autorisée. Le choix de la sélection à exécuter se fait en associant des valeurs aux différentes sections de code potentiellement exécutables. Dès lors que l'instruction sera exécutée, la variable considérée aura alors une certaine valeur, et la sélection pourra s'opérer.
Au niveau de la syntaxe, on introduit une telle instruction de la manière suivante : tout d'abord, le mot clé
switch doit figurer, immédiatement suivit de la variable (d'un type entier) placée entre parenthèses. Ensuite, on doit définir les sélections qui doivent être placées entre accolades. Chacune des sélections se définie ainsi : on place le mot clé
case suivit d'une valeur (comprise dans les bornes définies par le type utilisé), du caractère : puis d'une série d'instructions à exécuter. On remarquera que la sélection accepte un nombre quelconque d'instructions, par opposition aux autres instructions déjà étudiées.
Une remarque importante est à signaler : il est conseillé que l'instruction break apparaisse en fin de définition de la sélection. Ce n'est en aucun cas une obligation, mais si ce n'est pas le cas, et que la sélection considérée est traitée, le code de la suivante le sera lui aussi, et ce jusqu'à qu'un break soit rencontré. Cette propriété peut être utilisée, pourvu que vous en soyez bien conscient.
Si une sélection du switch est lancée son exécution ne s'arrêtera qu'au prochain break, ou, si l'on en rencontre pas, à la fin de l'instruction switch.
L'exemple suivante vous ferra, sans aucun doute, mieux comprendre les choses. Je vous invite à le tester et à le modifier de façon à ce que vous compreniez bien toute la sémantique de cette instruction.
Fichier "Switch.java"
public class Switch {
public static void main(String argv[]){
for(int i=0;i<10;i++)
switch(i){
case 9: System.out.println("Neuf"); break;
case 8: System.out.print("Huit"); System.out.println(""); break;
case 7: { System.out.print("Sept"); System.out.println(""); } break;
case 6: System.out.print("Six ");
case 5: System.out.println("Cinq"); break;
case 4:
case 3: System.out.print("Quatre Trois ");
case 2: System.out.println("Deux"); break;
case 1: System.out.println("Un"); break;
default: System.out.println("Zero");
}
}
}
Résultats
> javac Switch.java
> java Switch
Zero
Un
Deux
Quatre Trois Deux
Quatre Trois Deux
Cinq
Six Cinq
Sept
Huit
Neuf
>
Nous en avons donc fini avec ce chapitre et avec les structures de contrôles (les instructions) de base du langage. Nous allons, dans le chapitre suivant, étudier l'ensemble de notions liées à la programmation orientée objet en Java.
|
