Les structures de
contrôle
Les structures de contrôles permettent d’arrêter l’exécution linéaire des instructions (de
bas en haut et de gauche à droite)
Elles permettent d’exécuter conditionnellement une instruction, ou de réaliser une boucle
1.1. Structure conditionnelle
1.1.1. Instruction simple, bloc d’instruction
Définition 1 :
Une expression simple est une expression suivie d’un point-virgule ;
Attention : ; fait partie de l’instruction, ce n’est pas un séparateur
Définition 2 :
Un bloc d’instruction est une suite d’instructions délimitées par des {}
Syntaxe
{
/* suite d’instructions en tout genre */
}
Remarque : un bloc d’instruction peut remplacer une instruction simple
1.1.2. Instruction if
Syntaxe :
if (expression)
{
/*bloc d’instruction 1*/
}
else
{
/*bloc d’instruction 2*/
1
}
Si expression est vraie alors le bloc d’instruction 1 est exécuté sinon le bloc d’instruction 2 est exécuté
Exemple :
public class Max
{ public static void main (String args[])
{
float x,y;
[Link]("Donner deux flottants");
x = [Link]();
y = [Link]();
if (x < y)
[Link]("max = " + y);
else
[Link]("max = " + x);
}
}
Imbrication des instructions if
Un exemple : if (a<=b) if (b<=c) [Link](“ordonne”); else
[Link](“non ordonne”);
Un else se rapporte toujours au dernier if rencontré auquel un else n’a pas encore été attribué.
2
Instruction switch
Le switch est une structure multi branchement dans laquelle une valeur est comparée à plusieurs
constantes.
Syntaxe
switch (expression)
{
case exp1 : BlocInstruction1;
break;
case exp2 : BlocInstruction2;
break;
.
.
.
case expN : BlocInstructionN;
break;
default
BlocInstruction;
}
Remarque :
• L’instruction break est nécessaire pour un choix exclusif
• L’utilisation de default est optionnelle
• Tous les cas doivent être différents
• Expi doivent être des entiers (type int ou char)
Exemple :
public class Default {
public static void main (String[] args){
int n ;
[Link] ("donnez un nombre entier : ") ; n =
[Link]() ;
switch (n)
{ case 0 : [Link] ("nul") ;
break ;
case 1 : [Link] ("un") ;
break ;
default : [Link] ("grand") ;
}
[Link] ("Au revoir");
}
}
3
4
1.2. Structure Itératives (Boucles, Répétitions)
L’objectif de cours
Construire des programmes comportant des traitements répétitifs.
Définition
Les Structures Itératives (Boucles, Répétitions) permettent d'exécuter un bloc d'instructions (traitement)
plusieurs fois. En d’autres termes, ces structures permettent de répéter un certain nombre de fois un
ensemble d’instruction.
Le Nombre de répétitions peut être connu ou dépendre d'une condition.
En programmation, il existe trois (03) types de structures itératives
1. La Boucle Tant Que … Faire… FinTq;
2. La Boucle Répéter … Jusqu'à
3. La Boucle Pour.
Eléments de base d’une boucle :
- Initialisation de la boucle : est la valeur initiale de la boucle (clé).
- La condition d’arrêt : sans condition d’arrêt, la boucle devient infinie (cas à éviter).
- Le contrôle de la boucle : il sert à avancer la boucle (incrémentation).
1- Boucle while
Syntaxe :
while (expression)
{
/*bloc d’instruction*/
}
Le bloc d’instruction est exécuté tant que expression est vraie
Exemple :
public class While1 {
public static void main (String args[]){
int n, som ;
som = 0 ;
while (som < 100)
{
[Link] ("donnez un nombre : ") ;
n = [Link]() ;
som += n ;
}
[Link] ("Somme obtenue : " + som) ;
}
}
5
Boucle do….. while
Syntaxe
do
{
/*bloc d’instruction*/
} while (exp1) ;
Rque : Le bloc d’instruction est exécuté au moins une fois.
Exemple :
public class Do1 {
public static void main (String args[]){
int n ;
do
{ [Link] ("donnez un nombre >0 : ") ;
n = [Link]() ;
[Link] ("vous avez fourni " + n) ;
}
while (n <= 0) ;
[Link] ("reponse correcte") ;
}
}
Boucle for
Syntaxe :
for(exp1,exp2,exp3)
{
/* bloc d’instruction */
}
Où exp1 : initialisation d’une variable de contrôle appelée aussi index exp2 : expression conditionnelle
définissant la condition d’arrêt de la boucle
exp3 : une ou des expressions modifiant l’index
Remarque :
• Cette syntaxe peut être équivalente dans certains cas à while
• Il est possible d’omettre exp1, exp2 ou exp3 mais les ; restent obligatoires.
Exemple :
public class For1 {
public static void main (String args[]){
int i ;
for (i=1 ; i<=5 ; i++)
6
{
[Link] ("bonjour ") ;
[Link] (i + " fois") ;
}
}
}