Structures de base
Structure d'enchaînement
Les instructions sont exécutées en séquence dans l'ordre où elles apparaissent dans le programme.
instruction 1 ;
instruction 2 ;
.....
instruction n ;
Toute instruction se termine par un point-virgule.
Il ne s'agit pas d'un séparateur, mais bien d'un terminateur d'instruction : même la dernière instruction d'un bloc doit être terminée par ce caractère.
Le bloc d'instructions
-
Un bloc d'instructions peut contenir plusieurs instructions.
-
Il exprime l'ordre d'exécution des différentes instructions.
-
Il définit également le domaine de visibilité des variables dont il contient la déclaration.
-
Un bloc d'instructions peut apparaître partout où peut apparaître une instruction simple.
-
Le bloc commence par une accolade ouvrante et se termine par une accolade fermante.
Il faut de plus savoir qu'un bloc d'instructions impose une durée de vie aux variables qui sont déclarées à l'intérieur de ce bloc.
En fait une telle variable (dite locale) est stockée dans un espace de mémoire particulier appelé la pile d'exécution (ou stack, en anglais). L'état de la pile évolue au cours du temps en fonction des variables de l'on définit. Les variables locales manipulées seront définitivement perdues à la fin du bloc où elles étaient définies.
Structures d'alternative
C'est la traduction du schéma "Si alors sinon" vu en LDA.
L'instruction if permet de déclencher des traitements en fonction du résultat calculé par une expression de test.
Elle permet ainsi d'exécuter des instructions en fonction du résultat du test booléen qui suit le mot clé : if
Le résultat d'un test booléen est Vrai ( true ) ou Faux ( false ).
L'instruction suivant le test booléen sera exécuté si le résultat du test est VRAI.
Par exemple :
if ( X > Y )
System.out.println(" X est plus grand que Y " );
Contrairement à certains langages, il n'y a pas de mot clé then en Java.
Du coup, pour séparer la condition des instructions à exécuter, il faut placer la condition entre parenthèse (si vous ne respectez pas cette règle, une erreur vous sera signlaée).
Le branchement conditionnel (if) peut apparaître sous deux formes :
avec ou sans clause else .
D'une manière générale, la syntaxe est la suivante :
if ( expression logique )
instruction1
else
instruction2 ;
Si instruction2 est vide, pas besoin de mettre la partie else
Cette deuxième forme
if ( expression logique) instruction;
s'exécute de la manière suivante:
l'expression est évaluée; si le résultat renvoie le booléen true, alors l'instruction instruction est exécutée, sinon le branchement conditionnel est terminé.
Remarquez bien le point-virgule qui termine l'instruction if...
Il ne se trouve absolument pas derrière le test booléen ..!!
Il n'y a pas de mot-clé « then » dans la structure non plus.
-
Lorsque plusieurs instructions doivent être exécutées - si une condition est vérifiée ou non - ces instructions doivent être mises dans un bloc entre { et }.
-
Un tel bloc est équivalent à une instruction unique.
-
On parle aussi d'instruction composée
-
L'opérateur d'égalité est == (!= pour différent de)
-
Une expression de condition (après le if) doit obligatoirement renvoyer une valeur de type booléen.
-
Les conditions à tester sont toujours entre parenthèses et sont évaluées par ordre de priorité : parenthèses, gauche vers droite, priorité des opérateurs.
Cette forme de test permet d'imbriquer plusieurs tests.
if (ventes > = 3 * cible )
{ performance = "très bien"; prime = 500 ;}
else if (ventes > cible )
{performance = "satisfaisant"; prime = 200 ;}
else
{System.out.println ("effort à fournir"); }
Il faut bien respecter la syntaxe et surtout bien réfléchir à la logique de vos tests.
Cette forme de test "if imbriqué" est à éviter car il existe une instruction de contrôle prévue à cet effet.
En effet, cette structure peut-être remplacée par la structure de contrôle switch définie dans la partie suivante.
public class Compare1
{
public static void main(String args[])
{
int a = 10;
int b = 12;
System.out.println("L'entier A vaut "+a+".");
System.out.println("L'entier B vaut "+b+".");
if (a<b) System.out.println("A est plus petit que B.")
else if (a == b)
System.out.println("A est egal à B.")
else
System.out.println("A est plus grand que B.");
}
}
Le programme "compare1.java" a l'inconvénient de traiter deux nombres fixés une fois pour toute. Autre façon de procéder :
-
Arguments de la ligne de commande
Nous verrons qu'il est possible d'attribuer une valeur à ces nombres en utilisant la ligne de commande.
-
Autre solution
L'exemple suivant utilise la classe Lire qui permet de lire des valeurs de différents types
public class Maximum {
// Le fichier s'appelle Maximum.java
public static void main (String [] parametre)
{
int première, deuxième, laPlusGrande ;
System.out.print("Entrer une valeur :") ;
première = Lire.i() ;
System.out.print("Entrer une deuxieme valeur :") ;
deuxième = Lire.i() ;
if ((première > deuxième) | (première > 10))
{ System.out.println("valeur saisie première =" + première +" et deuxième = " + deuxième);
}
else
{ System.out.println("valeur saisie première =" + première +" et deuxième = " + deuxième) ; };
int nbre ;
for ( nbre=5 ; nbre < 20 ; nbre += 5)
{ System.out.println("nbre =" + nbre) ; } ;
System.out.println("nbre =" + nbre) ;
Choix multiple : switch
Si l'instruction de test if...else convient bien pour les situations définies uniquement par 2 conditions , elle n'est pas adaptée aux conditions multiples.
L'instruction switch permet elle aussi de déclencher des traitements en fonction d'une condition (d'un test). D'un certain point de vue, cette instruction est similaire à plusieurs if imbriqués. Néanmoins les performances sont souvent meilleurs avec un switch.
L'instruction de choix multiple switch permet d'effectuer un aiguillage sur plusieurs instructions, suivant la valeur retournée par une expression d'un des types suivants:
-
char
-
byte
-
short
-
int
Lorsque la valeur de l'expression est connue, elle est comparée à chacune des valeurs indiquées par les clauses case, en séquence dans l'ordre d'apparition des clauses.
Dès qu'une valeur indiquée par une clause est égale à la valeur calculée, le contrôle d'exécution est donnée à la séquence d'instructions qui suit cette clause.
Si aucune valeur ne correspond, le contrôle est donné à la clause default , si celle-ci existe, ou bien, l'instruction de choix multiple est considérée comme terminée.
L'instruction break permet d'arrêter l'instruction de choix multiple. Elle sera en général utilisée à la fin de la séquence d'instructions de chaque clause.
switch ( variable)
{
case val1 : instruction1 ; break;
case val2, val3 : instruction2 ; break;
case vali : instructionj ; break;
default instruction(j+1)
}
default est optionnel, cependant son utilisation est utile car permet de traiter tous les autres cas .
Bien retenir que Switch s'applique uniquement aux données types primitifs ( byte, char, short, int ).
switch (i % 2)
{
case 0 : System.out.println("C'est un nombre pair"); break;
case 1 : System.out.println("C'est un nombre impair"); break;
}
switch (carac)
// attention..pas de point-virgule !
{
case ‘+' : Z=x+y; break;
case ‘-' : Z=x-y; break;
case ‘*' : Z=x*y; break;
case ‘/' : Z=x/y; break;
default : System.out.println(" mauvaise touche..! ");
}
L'utilisation de l'instruction switch est souvent couplée à l'instruction break.
Effectivement, si un bloc d'instructions est exécuté et si celui-ci ne se termine pas par l'instruction break, alors l'exécution du bloc suivant (dans l'ordre de déclaration) sera lancé et ainsi de suite.
Répétition contrôlée par condition : Schéma while
Elle permet de répéter une ou plusieurs instructions de programme tant qu'une condition est vraie.
X = 0 ;
somme = 0 ;
while ( X < 14 )
// Tant que X est plus petit que 14 on réalise les 2 instructions
// suivantes
{
X += 2 ;
// X = X +2....donc X s'incrémente de 2 à chaque tour
somme = somme + X ;
}
// Dès que X atteindra la valeur 14 le programme quittera la boucle
// et se poursuivra vers les lignes suivantes...
Dans cette boucle la condition est testée en début de boucle.
Si la condition est fausse dès le début, la boucle ne sera pas exécutée et aucune des instructions se trouvant dans la boucle ne sera exécutée.
Répétition contrôlée par condition : Schéma do ... while
Avec cette boucle, la condition est testée en fin de boucle.
Ainsi, quelque soit l'état de la condition les instructions seront exécutées au moins une fois.
X = 0 ;
somme = 0 ;
do
// Faire sans condition
{ X += 2 ;
// X = X +2....donc X s'incrémente de 2 à chaque tour
somme = somme + X ;
} while ( X < 14)
// Dès que X atteindra la valeur 14 le programme quittera la boucle
// et se poursuivra vers les lignes suivantes...
Dans cet exemple, combien de fois la boucle est-elle exécutée ? a-t-on le même résultat que la boucle précédente ?
Sinon, comment modifier cette boucle pour obtenir le même résultat ?
Il est possible de rajouter un test pour forcer la sortie de la boucle.
do
{ // idem que ci-dessus mais les instructions de ce
// bloc sont exécutées au moins une fois, que la
// condition, en fin de boucle, soit vraie ou non
} while (condition);
Répétition contrôlée par indice : Schéma for
Elle est utilisée pour répéter des actions un certain nombre de fois . Elle peut être paramétrée de manière plus ou moins complexe.
Elle est très employée.
Elle apparaît dans tous les langages de programmation, mais avec une syntaxe et une souplesse qui dépendent de ce langage.
L'utilisation de la boucle for est vraiment très simple.
Vous introduisez l'instruction par le mot clé for, puis vous devez fournir trois expressions (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 dont voici la syntaxe :
for (init; expression_test; incrémentation)
{
// bloc exécuté tant que la condition est vraie
}
Par exemple
for (i=1; i <= 10; i++)
on définit trois expressions :
-
initialisation de la variable de boucle (appelée aussi index de la boucle) (ex: i=1),
-
condition de test devant être vérifiée pour que l'itération suivante de la boucle soit effectuée (ex : i <= 10). Si cette condition n'est pas réalisée, on stoppe l'itération
-
et expression d'incrémentation de la variable de boucle (ex: i++). Elle sert à modifier l'état de la variable après chaque itération
public class somme
{
public static void main(String[] arg)
{ int i, donnée = 0;
for (i = 1; i <= 100; i++ )
donnée += i;
//les accolades ne sont pas nécessaires dans ce cas car une seule action existe.
System.out.println("Voila la somme des 100 " + "premiers entiers : " + donnée);
}
}
-
En principe pas de point virgule en fin de ligne for : sinon les instructions suivant l'instruction for et devant être effectuées à chaque tour de boucle seront considérées hors de la boucle .
-
Il est possible de ne déclarer la variable d'index que dans la boucle for.
Elle ne sera alors connue qu'au sein de cette boucle.
Par ex.:
for ( int nbre=5 ; nbre < 200 ; nbre += 5)
{ actions diverses .... }
Question : Comment faire pour rendre accessible i en dehors de la boucle for ?
-
Pour forcer la sortie d'une boucle on utilise l'instruction : break.
(on poursuit l'exécution après le for )
-
Pour forcer l'exécution de l'itération suivante on utilise l'instruction : continue
for (i=1; i <= 10; i++)
{
System.out.println (« i »);
.......
if (i == 1 ) continue ;
if ( arret ) break ;
}
public class ExecIteration
{
public static void main(String arg[])
{
for (int i=1 ; i<=4 ; i++)
{
for (int j=1; j<=i ; j++)
System.out.print("*"); System.out.println(); }
} }
Le programme donnera la sortie suivante:
*
**
***
****
Synthèse pour les structures de répétition
Trois styles de boucles sont utilisables pour mettre en place des boucles (on parle aussi d'itérations) et d'en contrôler leurs exécutions.
-
Boucles indéterminées : à employer lorsque l'on ne sait pas combien de fois la boucle doit être répétée
-
la boucle while (condition) instruction
Remarquez que le test de la boucle while s'effectue avant l'exécution du corps de la boucle et donc ce bloc peut ne jamais être exécuté
-
la boucle do instruction while (condition) Cette fois le corps de la boucle est exécuté avant de tester la condition. Schéma à utiliser si la boucle doit être exécutée au moins une fois
-
-
Boucles déterminées : à employer lorsque le nombre d'itération est connu (constante ou valeur d'une variable)
-
c'est la boucle for
-
Remarque : lorsque vous déclarez une variable dans le premier élément d'une instruction for, la portée de la variable s'étend jusqu'à la fin du corps de la boucle !!! Vous ne pouvez donc pas utiliser cette variable en dehors de la boucle for.
for (int i = 1 ; i <= 10; i++)
{
.......
} // i n'est plus défini
-
