27/04/2022

POO en Java
Ch. VI

Généralités sur la structure

lexicale de Java

I. Variables
• Les variables d’instances:
– sont déclarées en dehors de toute méthode
– conservent l’état d’un objet, instance de la classe
– sont accessibles et partagées par toutes les méthodes de la classe

• Les variables locales:

– sont déclarées à l’intérieur d’une méthode
– conservent une valeur utilisée pendant l’exécution du bloc dans
lequel elles sont définies
– ne sont accessibles que dans le bloc dans lequel elles ont été
déclarées

1
 27/04/2022

1. Déclaration des variables:

En Java, toute variable utilisée doit être déclarée avant son utilisation.
La syntaxe de la déclaration :

type identificateur;
Où
- type désigne le type de la variable déclarée
- identificateur est une suite de caractères pour désigner les
différentes entités manipulées par un programme: variables,
méthode, classe, objet, …

Remarques: concernant les identificateurs:

- Tous les caractères sont significatifs.
- On fait la différence entre les majuscules et les minuscules.

- Mots réservés: un identificateur ne peut pas correspondre à un

mot réservé du langage (par exemple: if, else, while, ..., ).
Exemples:
int val;
double delta;
Rectangle r1; /* Rectangle est une classe */

String interface; /* interface est un mot réservé */

int const; /* const est un mot réservé */

4

2
 27/04/2022

Mots réservés du langage Java

2. Initialisation des variables:

Une variable doit être initialisée (recevoir une valeur)

avant d’être utilisée dans une expression.
Si elles ne sont pas initialisées par le programmeur, les
variables d’instance et les variables de classe reçoivent
les valeurs par défaut de leur type (0 pour les types
numériques, par exemple).
L’utilisation d’une variable locale non initialisée par le
programmeur provoque une erreur (pas d’initialisation
par défaut) à la compilation.

3
 27/04/2022

Exemple

On peut initialiser une variable en la déclarant.

La formule d’initialisation peut être une expression
simple ou complexe :

double prime = 1200.0;

Etudiant e1 = new Etudiant("HAMDI", "Mostafa");

double salaire = prime + 6500.0;

II. Style de programmation non standard

Conventions de nommage en Java: pas obligatoires, mais très
fortement recommandées (essentielles pour la lisibilité du code et
sa maintenance).
• Identificateur: pas d'emploi de $ (et de caractères non ASCII)
on ne commence pas par un chiffre
• Nom de classe :
– Si le nom de la classe est composé de plusieurs mots, ils
sont accolés (on ne les sépare pas  le trait _ souligné).
– Commencez chaque mot par une majuscule: exemple:
HelloWorld, ClasseTest, MonPremierProgramme.

4
 27/04/2022

• Nom de variable ou méthode :

– Si le nom est composé d’un seul mot: la première lettre est
miniscule.
– Si le nom est composé par plusieurs mots, ils sont accolés et
respectent la règle suivante:
• La première lettre du premier mot est miniscule.
• La première lettre des autres mots est majuscule, exemples:
maPremiereNote, initialiseAttribut(), calculTaux(), main(),
objEtudiant, …
• Les constantes: majuscules et séparation des mots par _ :
VALEUR_MAX;
• Usage non recommandé :
* mapremierevariable
* ma_premiere_variable

Nom de classes, de variables et de méthodes

 Un nom peut être constitué de lettres, de chiffres et du caractère souligné _

 Il ne peut pas commencer par un chiffre

 Le caractère $ est utilisable mais à éviter

 Les mots réservés (if, class, int, const,…) ne peuvent pas être utilisés

 Les développeurs ont défini un consensus de nommage :

 Les mots du langage sont en minuscule
 Les noms de classe commencent par une majuscule
 Les noms de méthodes et de variables comment par une minuscule
 Chaque mot qui compose le nom commence par une majuscule

10

5
 27/04/2022

Les commentaires
L’utilisation de commentaires est fortement recommandée.
Ils sont sautés par le compilateur (pas de ‘;’ à la fin)
Il existe trois types de commentaires en Java :
1. Monoligne. Exemple : int num=1; // déclaration du compteur
2. Multiligne. Exemple : /* commentaires ligne 1
commentaires ligne 2 */
3. De documentation automatique. Ils se placent généralement juste avant
une déclaration (d'attribut ou de méthode). Exemple:
/**
* commentaire de la méthode
* @param val la valeur à traiter
* @return Rien
* @deprecated Utiliser la nouvelle méthode XXX
*/
Ils sont récupérés par l'utilitaire javadoc (fourni par le JDK)
et inclus dans la documentation ainsi générée sous format HTML

11

Mise en page des programmes

La mise en page d’un programme Java est libre.
- Une instruction peut être étendue sur plusieurs lignes.
- Une ligne peut comporter plusieurs instructions.

Emploi du code Unicode:

Java utilise le codage Unicode, qui est basé sur 2 octets (16 bits), par
conséquent on peut coder 65 536 symboles, ce qui permet de couvrir la
plus part des symboles utilisés dans le monde. Pour assurer la
portabilité, le compilateur commence par traduire le fichier source en
Unicode.

• On peut, par exemple, utiliser l’identificateur élément: int élément;

• On peut aussi utiliser le code Unicode d’un caractère (mais à éviter
pour la lisibilité) de la manière suivante: \uxxxx représente le caractère
ayant comme code Unicode la valeur xxxx.
Par exemple \u0041 représente le caractère A.

12

6
 27/04/2022

III. L’affectation
• L’opération d’affectation affecte ( assigne) une valeur à une
variable. Elle est réalisée au moyen de l’opérateur « = ».

la syntaxe : identificateur = valeur ;

Signifie prendre la valeur du côté droit et la copier du côté
gauche.
• identificateur : désigne une variable.
• valeur : est une constante, une variable ou une expression qui
retourne une valeur du même type que la variable référencée
par identificateur .

13

1. Cas des types primitifs

• Soient a et b de type primitif. L’affectation a=b; signifie que le
contenu de b est copié dans a.
Exemple:
a=2;
b=15;
a=b; // La nouvelle valeur de a est 15
après affectation a et b existent et ont tous la même valeur 15.

Remarque: si ensuite on modifie le contenu de a, alors le contenu

de b ne sera pas modifié.
a=23; // La valeur de b reste 15

14

7
 27/04/2022

2. Cas des Objets

Soient objA est objB deux objets d’une classe C donnée,
L’affectation objA=objB; signifie qu’on copie la référence de objB dans objA.

1. Les références objA et objB pointeront vers le même objet référencé par objB.

2. L’objet qui a été initialement référencé par objA existe toujours, mais on n’a
aucun contrôle sur lui (il reste inaccessible)

objA= new C() Etat de Etat de

objA objA
objA objA objA=objB

Etat de objB
objB objB Etat de
objB= new C() objB

15

Exemple:
class A {
public int i;
}
public class TestAffectation {
public static void main(String[] args) {
A a=new A(); A b=new A();
a.i=6; b.i=11;
a=b; // a et b contiennent la même référence, on a: a.i=11
a.i=20; // b.i = 20
Contrairement à ce qu’on a vu pour les types
b.i=13; // a.i = 13 primitifs, cette liaison ne peut se casser que si
on fait une nouvelle instanciation de l’objet a
}
a= new A() Instance Instance
a a
a a

a= b
Instance b Instance
b b b
b= new A()

16

8
 27/04/2022

Exemple:
class A {
public int i;
}

public class AffectationObjet {

public static void main(String[] args) { valeur de a.i=6

A a=new A(); A b=new A(); valeur de b.i=11
a.i=6; b.i=11; Après affectation a=b valeur de a.i=20
System.out.println("valeur de a.i="+a.i);
Après affectation a=b valeur de b.i=20
System.out.println("valeur de b.i="+b.i);
Après affectation a=b valeur de a.i=13
a=b; Après affectation a=b valeur de b.i=13
a.i=20; // b.i = 20
System.out.println("Après affectation a=b valeur de a.i="+a.i);
System.out.println("Après affectation a=b valeur de b.i="+b.i);
b.i=13; // a.i = 13
System.out.println("Après affectation a=b valeur de a.i="+a.i);
System.out.println("Après affectation a=b valeur de b.i="+b.i);
}
}
17

Exercice: valeur de a.i=6

class A {
public int i;
}
public class AffectationObjet {
public static void main(String[] args) {
A a=new A(); A b=new A();
a.i=6; b.i=11;
System.out.println("valeur de a.i="+a.i);
System.out.println("valeur de b.i="+b.i);
valeur de b.i=11
Après affectation a=b valeur de a.i=20
Après affectation a=b valeur de b.i=20
Après affectation a=b valeur de a.i=13
Après affectation a=b valeur de b.i=13
………………….
Après Cassure de la liaison a=b, la valeur de a.i=1000
Après Cassure de la liaison a=b, la valeur de b.i=13

a=b;
a.i=20; // b.i = 20
System.out.println("Après affectation a=b valeur de a.i="+a.i);
System.out.println("Après affectation a=b valeur de b.i="+b.i);
b.i=13; // a.i = 13
System.out.println("Après affectation a=b valeur de a.i="+a.i);
System.out.println("Après affectation a=b valeur de b.i="+b.i);

A c=new A();
c.i=1000;
System.out.println("valeur de c.i="+c.i);
a=c;
System.out.println("Après Cassure de la liaison a=b, la valeur de a.i="+a.i);
System.out.println("Après Cassure de la liaison a=b, la valeur de b.i="+b.i);
}
18
}

9
 27/04/2022

IV. Types de données en Java

2 grands groupes de types de données sont manipulés par Java:

– types primitifs
– objets (instances de classe)

19

1. Types primitifs
• Booléen:
Boolean : prend deux valeurs true ou false
• Caractère (un seul caractère) :
char : codé sur 2 octets par le codage Unicode
• Nombres entiers :
byte: représenté sur 1 octet (8 bits),
short: représenté sur 2 octets (16 bits),
int : représenté sur 4 octets (32 bits),
long : représenté sur 8 octets (64 bits).
• Nombres à virgule flottante :
float : flottant (IEEE 754) 32-bit
double : flottant (IEEE 754) 64-bit

20

10
 27/04/2022

1.1. Type booléen

• Sert à représenter une valeur logique du type vrai/faux:

– Une variable de type booléen est déclarée par:

boolean b;
b prend une des deux valeurs true ou false
• C’est un véritable type:
– Il est retourné par les opérateurs de comparaison
– Il est attendu dans tous les tests

• ne peut pas être converti en entier

21

1.2. Type caractère

• Permet de manipuler des caractères: Java représente un caractère sur 2 octets (16 bits)
16-bit => 65536 valeurs : presque tous les caractères de toutes les écritures.
Ne sont affichables que si le système possède les polices de caractères adéquates.
• Une variable de type caractère est déclarée par: char c;
• Constantes de type caractère doivent être écrites entre simples quottes .
Exemple : 'a‘ , 'Z' , ‘E’
Les caractères disposant d’une notation spéciale.

Notation Code Unicode Abréviation usuelle Signification

\b 0008 BS(Back Space) Retour arrière
\t 0009 HT(Horizontal Tabulation) Tabulation horizontale
\n 000a LF(line Feed) Saut de ligne
\f 000c FF(Form Feed) Saut de page
\r 000d CR(Cariage Return) Retour chariot
\" 0022
\’ 0027
\\ 005c

22

11
 27/04/2022

1.3. Nombres entiers

Type Désignation Longueur Valeurs Min et Max

byte octet signé 8 bits -128 à 127

short entier court signé 16 bits -32768 à 32767

int entier signé 32 bits -2147483648 à 2147483647

long entier long signé 64 bits -9223372036854775808 à
9223372036854775807

Une constante « entière » est par défaut de type int.

23

• Constantes nombres: Une constante « entière » est par défaut de type int.
Si elle est suffixée par « L » ou « l » alors elle est de type long.
Exemple:
108 // 108 constante de type int, représentée sur 32 bits
108L // 108 constante de type long, représentée sur 64 bits
• Représentation en octal (8bits) et hexadécimale (16 bits).
Exemple :
014 // 14 en octal (base 8) = 12 en décimal
0xA7 // A7 en hexadécimal (base 16) = 167 en décimal

• Conversion automatique (implicite) seulement vers les types entiers plus

grands (taille plus grande).
(byte → short, short → int, int → long) et vers les types flottants.

24

12
 27/04/2022

1.4. Les nombres flottants

• float : environ 7 chiffres significatifs ;
– Valeur absolue (arrondie) maximal 3,4 x 1038 ( constante prédéfinie
Float.MAX_VALUE)
– Valeur absolue (arrondie) minimal 1,4 x 10-45 (constante prédéfinie
Float.MIN_VALUE)

• double : environ 15 chiffres significatifs ;

– Valeur absolue maximal (arrondie) 1,8 x 10308 (constante prédéfinie
Double.MAX_VALUE)
– Valeur absolue minimal (arrondie) 4,9 x 10-324 (constante prédéfinie
Double.MIN_VALUE)

25

Constantes nombres
• Une constante réelle est par défaut de type double.
• Pour spécifier un float, il faut la suffixer par « F » ou « f ».
• Conversion automatique (implicite) : seulement float → double
Exemples:
.567e2 // 56,7 de type double
5.123E-2F // 0,05123 de type float
float x=2.5f //ok
double y = 2.5; //ok
float x = 2.5; // Erreur: conversion double à float
// 2.5 est par défaut de type double

26

13
 27/04/2022

2. Type objet: Constante null

• null : valeur d'une "référence vers rien" (pour tous
types de références)
• Elle indique qu’une variable de type non primitif ne
référence rien) ; convient pour tous les types non
primitifs

27

3. Transtypage
• Java est un langage fortement typé
• Dans certains cas, il est nécessaire de forcer le programme à
changer le type d’une expression. On utilise pour cela le cast
(transtypage) :
(type-forcé) expression
Exemple:
int i=13; // i codé sur 32 bit; 13 constante int codée sur 32 bits
byte b=i; // Erreur: pas de conversion implicite int →byte

Pour que ça marche, on doit faire un cast (un transtypage) c’est-à-

dire on doit forcer le programme à changer le type de int en byte.

byte b=(byte)i; // de 32 bits vers 8 bit. b vaut 13 codé sur 8 bits

28

14
 27/04/2022

Casts autorisés
• En Java, 2 seuls cas sont autorisés pour les casts :
– entre types primitifs,
– entre classes mère/ancêtre et classes filles.

29

3.1. Casts entre types primitifs

Un cast entre types primitifs peut occasionner une perte de données sans
aucun avertissement ni message d'erreur.

• int i=13; // i sur 32 bit; 13 codé sur 32 bits

byte b=(byte)i;
// b vaut 13 car conversion de 32 bits vers 8 bit (On considère les 8 bits
de poids le plus faible). i est un entier « petit »

• int i=256; // i sur 32 bit; 256 codé sur 32 bits

byte b=(byte)i;
// b vaut 0 car conversion de 32 bits vers 8 bits (On considère les 8 bits
de poids le plus faible).

30

15
 27/04/2022

• Une affectation entre types primitifs peut utiliser un cast implicite si elle ne
provoque aucune perte
Exemple:
byte b=120;
Ne provoque pas d’erreur (caste implicite) car 120 est dans max/min pour les
byte.

byte b=130;
Provoque une erreur "cannot convert from int to byte " car 130 hors max/min.
Dans ce cas le cast explicite est obligatoire. Mais attention au perte
d’information:
byte b=(byte)130; // renvoie -126.

• Pour une affectation non statique, le cast est obligatoire :

int i = 120;
byte b=i;
Provoque une erreur même si la valeur de i est dans l’intervalle max/min des
byte. On écrit:
byte b = (byte)i ; // cast obligatoire, sinon erreur

31

• Les casts de types « flottants » vers les types entiers tronquent les
nombres :
float x=1.99f;
int i = (int)x; // i = 1, et pas 2. On fait une troncature et non un
arrondie.

• Attention, traduction peut donner un résultat totalement aberrant

sans aucun avertissement ni message d'erreur :
int c = (int)1e+30; // c = 2147483647 ! (valeur max de int)

int x = 10, y = 3;
double z;
z=x/y; // donne z=3.0; car x/y donne int/int soit 3

si on veut que z=3.3333 et pas 3.0

z = (double)x / y; // cast de x suffit

32

16
 27/04/2022

3.2. Casts entre entiers et caractères

• Ils font correspondre un entier à un caractère qui a
comme code Unicode la valeur de l’entier
• La correspondance char → int, long s’obtient par
cast implicite

• Le code d’un char peut aller de 0 à 65.535 donc

char → short, byte nécessite un cast explicite (short
ne va que jusqu’à 32.767)

• Les entiers sont signés et pas les char donc long, int,
short ou byte → char nécessite un cast explicite

33

Tableau récapitulatif de conversion de types

34

17
 27/04/2022

V. Principaux opérateurs
• affectation : =
• arithmétiques : + - * / %
• comparaisons : < <= > >= == !=
• booléens : && || ! ^
• opérations bit-à-bit (sur les entiers) :
& | ^ ~ << >> >>>
• opération et affectation simultanées :
+= -= *= /= %= &= |=
^= <<= >>= >>>=
• pré/post-incrémentation : ++
pré/post-décrémentation : --
• opérateur ternaire : ?:
• création tableau ou objet (allocation mémoire) : new
• test de type des références : instanceof

35

Les opérateurs: affectation

le signe = est l'opérateur d'affectation et s'utilise avec une
expression de la forme variable = expression.
L'opération d'affectation est associatif de droite à gauche: il
renvoie la valeur affectée ce qui permet d'écrire: x = y = z = 0;
Liste d’opérateurs abrégée d’affectation:
Opérateur Exemple Signification
= a=10
+= a+=10 a= a + 10
-= a-=10 a= a - 10
*= a*=10 a= a * 10
/= a/=10 a= a / 10
%= a%=10 Reste de la division
^= a^=10 a= a ^ 10
36

18
 27/04/2022

Les opérateurs: comparaisons

Java propose des opérateurs pour toutes les comparaisons:
> (strictement supérieur) & (ET binaire)
< (strictement inférieur) ^ (OU exclusif binaire)
>= (supérieur ou égal) | (OU binaire)
<= (inférieur ou égal) ?: (opérateur conditionnel)
== (égalité) Exemple: a ? b : c
équivalent à : si a alors b
!= (différent de)
sinon c
&& (ET logique)
|| (OU logique) min = x<y ? x : y
Remarque: b et c doivent
retourner le même type
37

Priorité des opérateurs

Priorités des opérateurs du plus au moins prioritaire:
1) les parenthèses: ( )
2) les opérateurs d'incrémentation, décrémentation: ++ , --
3) les opérateurs de multiplication, division, et modulo: *, / , %
4) les opérateurs d'addition et soustraction: +, -
5) les opérateurs de décalage: << et >>
6) les opérateurs de comparaison: < , >,<=,>=
7) les opérateurs d'égalité: ==, !=
8) l'opérateur OU exclusif: ^
9) l'opérateur ET : &
10) l'opérateur OU : |
11) l'opérateur ET logique: &&
12) l'opérateur OU logique: ||
13) les opérateurs d'assignement: =, += , -=
Remarque: Les parenthèses ayant une forte priorité, l'ordre d'interprétation des opérateurs
peut être modifié par des parenthèses.
https://fr.wikibooks.org/wiki/Programmation_C/Op%C3%A9rateurs 38

19
 27/04/2022

Les opérations arithmétiques

 Les opérateurs arithmétiques se notent :

+ (addition)
- (soustraction)
* (multiplication)
/ (division)
% (reste de la division)

 Ils peuvent se combiner à l'opérateur d'affectation.

+= -= *= /= %= &= |=

39

Les opérations arithmétiques

L'incrémentation et la décrémentation
Les opérateurs d'incrémentation et de décrémentation sont:
n++, ++n , n-- , --n
L'opérateur ++ (resp. --) renvoie la valeur
avant incrémentation s'il est postfixé et
après incrémentation s'il est préfixé.

Exemple :
System.out.println(x++) ↔ System.out.println(x); x = x + 1;
System.out.println(++x) ↔ x = x + 1; System.out.println(x);

40

20
 27/04/2022

Les opérations arithmétiques

Exercice: Quel sera le résultat de l’exécution du programme suivant:

class Test {
public static void main(String args[]) {
int n1=0; int n2=0;
System.out.println("n1 = " + n1 + " n2 = " + n2); n1=n2++;
System.out.println("n1 = " + n1 + " n2 = " + n2); n1=++n2;
System.out.println("n1 = " + n1 + " n2 = " + n2); n1=n1++;
System.out.println("n1 = " + n1 );
} n1 = 0 n2 = 0
} n1 = 0 n2 = 1
n1 = 2 n2 = 2
n1=n1++; attention: n1 ne change pas de valeur n1 = 2 41

Les opérations arithmétiques: Exo

21
 27/04/2022

Exercice: Quel sera le résultat de l’exécution du programme suivant:

public class Incrementation16 {

public static void main(String args[]) {

int i=10, j=5, k=0; valeurs initiales
System.out.println("valeurs initiales \n i = " + i + " j = " + j + " k= " + k); i = 10 j = 5 k= 0

k=j+++i+j; System.out.println("i = " + i + " j = " + j + " k= " + k); i = 10 j= 6 k= 21

int a=10 ,b=5, c=0;

c=b---a-b; System.out.println("a = " + a + " b = " + b + " c= " + c); a = 10 b= 4 c= -9

int d=10, e=5, f=0;

f=e+++d+++e--; System.out.println("d = " + d + " e = " + e + " f= " + f); d = 11 e= 5 f= 21

int l=10, m=5, n=0;

n=--m-l---m; System.out.println("l = " + l + " m = " + m + " n= " + n); l= 9 m= 4 n= -10

int x=10, y=5, z=0;

z=++y+x+++y; System.out.println("x = " + x + " y = " + y + " z= " + z); x = 11 y= 6 z= 22
}
}

43
NB l’opérateur incrémentation prioritaire sur addition et soustraction

VI. Notion de portée et de durée de vie des objets

• Un bloc est un ensemble d’instructions délimité par les accolades { et }
• Les blocs peuvent être emboîtés les uns dans les autres
• On peut grouper plusieurs instructions en un bloc délimité par des accolades { et }.
Le concept de portée fixe simultanément la visibilité et la durée de vie des noms
définis dans cette portée.
Exemple 1:
int a=1, b=2;
{ //début de bloc
int x=a;
x = 2*a+b;
} //fin de bloc
x = 3; //ERREUR: x n’est pas connu ici
• Remarque : La portée ( zone de validité de la déclaration) d'une variable va de sa
déclaration jusqu'à la fin du bloc où elle est déclarée. Elle est fixée par les accolades
{ }.

44

22
 27/04/2022

les variables locales ne sont pas initialisées de

façon implicite (contrairement aux champs des
objets).
Toute variable locale, y compris une référence
à un objet, doit être initialisée avant d’être
utilisée, faute de quoi on obtient une erreur de
compilation.

45

Exemple 2:
{
int x=12; // x est accessible
{
int q;
q=x+100; // x et q tous les deux sont accessibles
}
x=6; // x est accessible

q=x+2; /* Erreur: q est hors de portée:

la portée d'une variable va de sa déclaration
jusqu'à la fin du bloc où elle est déclarée */
}

46

23
 27/04/2022

Attention: Ceci n’est pas permis en Java

{
int x=10;
{
int x=20; // valable en C, C++, illégale en Java, variable locale dupliquée
// on peut écrire x=20;
}
}

47

Portée des objets : Considérons une classe nommée ClasseA et qui a une
méthode publique nommée f().
{ objetA
Attribut1
ClasseA objA=new ClasseA(); Attribut2
….

} // fin de portée
objA.f(); // Erreur car la référence objA est hors portée.

Remarque:
- La référence ObjA disparaît à la fin de la portée,
- par contre l’objet qui a été référencé par objA existe toujours, mais on
n’a aucun contrôle sur lui (il reste inaccessible).
Les objets n’ont pas la même durée de vie que les types primitifs.

48

24
 27/04/2022

Exemple 3:
• La portée d’une variable locale est limitée au bloc constituant la méthode
où elle est déclarée.
• Une variable locale ne doit pas posséder le même nom qu’un argument
muet de la méthode

void f(int n)
{ float x ; // variable locale à f
float n ; // il est interdit en Java de redéfinir une variable déjà
// déclarée dans une méthode
.....
}
void g ()
{ double x ; // variable locale à g, indépendante de x locale à f
.....
}

49

Gestion de la mémoire (Garbage Collector)

Lorsqu’on perd le contrôle sur un objet. Il persiste et il occupe de
la mémoire.
- Il n’existe aucun opérateur explicite pour détruire l’objet dont on
n’a pas besoin,
- mais il existe un mécanisme de gestion automatique de la
mémoire connu sous le nom de ramasse miettes (en anglais
Garbage Collector). Son principe est le suivant:
- A tout instant on connaît le nombre de références à un objet
donné.
- Lorsqu’il n’existe plus aucune référence sur un objet, on est
certain que le programme ne peut pas y accéder, donc l’objet
devient candidat au ramasse miette.

50

25
 27/04/2022

Le ramasse-miettes (garbage collector) est une tâche qui

– travaille en arrière-plan
– libère la place occupée par les instances non référencées
– compacte la mémoire occupée

• Il intervient
– quand le système a besoin de mémoire
– ou, de temps en temps, avec une priorité faible

51

VII. Instructions de contrôle

Java propose un ensemble d'instructions qui permettent

d'organiser et de structurer les traitements.
Elles sont appelées structures de contrôle et sont :

1. Les branchements conditionnels

2. Les boucles
L'utilisation de ces structures de contrôle est similaire à
celle des autres langages de programmation.

52

26
 27/04/2022

1. Structure alternative « if… else »

Soit exprBool une expression Booléenne qui retourne true (vrai) ou false (faux)

if (exprBool) {
instructions; // exécutées si exprBool retourne true
}

if (exprBool) {
instructions1 ; // exécutées si exprBool retourne true
}
else {
instructions2; // exécutées si exprBool retourne false
}

53

Exemple :

int n = 3 ;

if ( n > 2 ) {
System.out.println (" n est supérieur à 2 ") ;
}

else {
System.out.println (" n est inférieur ou égal à 2 ") ;
}

54

27
 27/04/2022

if (exprBool1) {
instructions ; // Exécutées si exprBool1 retourne true
}
else if (exprBool2) {
instruction;
// Exécutées si exprBool1 retourne false et exprBool2 retourne true.
}
else {
// ...
}

Remarque: Un bloc serait préférable, même s’il n’y a qu’une seule

instruction.

55

L'instruction suivante est ambiguë :

if (exprBool1) if (exprBool2 ) Instruction1 ; else Instruction2 ;

Le compilateur résout l'ambigüité de cette instruction ainsi (rattachement du

else au dernier if):

if (exprBool1) if (exprBool2) Instruction1 ; else Instruction2 ;

Si l'on veut que l'instruction « else Instruction2 ; » soit rattachée au

premier if, il est nécessaire de parenthèser (introduire un bloc) le second if :

if (exprBool1) {
if (exprBool2) Instruction1 ;
}
else Instruction2

56

28
 27/04/2022

2. Expression conditionnelle (opérateur ternaire)

L’expression:

expressionBooléenne ? expression1 : expression2

Est équivalente à:

if (expressionBooléenne) {
expression1;
}
else {
expression2;
}

57

Exemples:
int x, y; int min, a, b;
if (x % 2 == 0) if (a<b)
y = x + 1; min=a;
else else
y = x; min=b;

Est équivalent à
Est équivalent à
int x;
int a, b;
int y = (x % 2 == 0) ? x + 1 : x; int min = a<b ? a : b;

58

29
 27/04/2022

3. Cas multiple: Distinction de cas suivant une valeur

switch(expression) {
case val1: instructions; // exécutées si expression ==val1
break; // Attention, sans break, les instructions du cas suivant sont exécutées !
case val2: instructions; // exécutées si expression ==val2
break;
...
case valn: instructions; // exécutées si expression ==valn
break;
default: instructions; // exécutées si aucune des valeurs prévues
break;
}
• Expression est de type char, byte, short, ou int, ou de type String (Java 7)
• S’il n’y a pas de clause default, rien n’est exécuté si expression ne correspond
à aucun case (aucune valeur prévue).

59

Exemple:
int mois= 11;
switch (mois) {

case 1: System.out.println("Janvier");
break;
case 11: System.out.println("Novembre");
break;
default: System.out.println("Mois Invalide ");
break;
}
Remarque: N'utiliser le switch qu'avec des break afin de bénéficier
de la structuration.

60

30
 27/04/2022

Il est toujours possible d'utiliser des instructions if … else imbriquées

pour représenter un switch structuré (switch avec break)

Programmes équivalents switch et if...else :

61

Répétitions « tant que »

4. Boucles de répétitions
Il existe deux types de boucles :
1
while (expressionBooléenne) {
instructions; // corps de de la boucle
}
répéter un certain nombre d’instructions
un certain nombre de fois jusqu’à
Exemple ce qu’une condition soit réalisée.
int x = 1 ;
System.out.println(" ===> Avant la boucle") ;
while (x < 4 ) {
System.out.println("Dans la boucle") ;
System.out.println("La valeur de x est : " + x) ;
x++;
}
System.out.println(" ===> Après la boucle") ;

62

31
 27/04/2022

Boucles de répétitions Répétition « faire tant que »

2
do {
instructions; // corps de de la boucle
} while (expressionBooléenne);

le corps de la boucle est

exécuté au moins une fois

Remarque: Dans le cas où le corps de la boucle est formée d’une seule instruction pas
besoin de mettre les accolades { } pour marquer le début et la fin du bloc.

63

Comparaison des 2 boucles de répétitions

Boucle WHILE: Boucle DO..WHILE:
while ( condition) { do {
... ...
} while ( condition)
}

Similitudes: Dans les deux boucles le code est

exécuté tant que la condition est vraie. Lorsque la
condition passe à faux le bloc du While est sauté

Différence: Dans do…while, la boucle est au moins

exécutée une fois quelque soit la valeur de la condition
64

32
 27/04/2022

5. Boucle d’itération: répétition for

init;
for(init; test; incréments){ while (test) {
instructions; // corps de la boucle instructions;
} incrémentations;
}
– init (initialisation): Déclaration et/ou affectations, séparées par des virgules
– incrémentations : expressions séparées par des virgules
– Test: expression booléenne
Remarque: Dans le cas où le corps de la boucle est formée d’une seule instruction
pas besoin de mettre les accolades { } pour marquer le début et la fin du bloc
Exemple: L’index peut être exploité dans les instructions de la boucle
for ( int i = 0 ; i<10 ; i++) {
System.out.println("le carré de"+i+ "est :"+i*i);
}
65

Boucle d’itération for… Remarques

1. L'initialisation, la condition et la modification de l'index sont optionnelles
Exemple: for ( ; ; ) { ... } // boucle infinie est équivalente à while (true);
2. Il est possible d'inclure plusieurs traitements dans l'initialisation et
la modification de la boucle:
Exemples:
for (i = 0 , j =0 ; i * j < 1000 ; i++ , j+= 2) { ....}

for ( i = 10, k = i ; i>-450 ; k += i , i -= 15) { ....}

66

33
 27/04/2022

Boucle d’itération for… Remarques

String tab[]=new String[5];

Itération : for
for(int i=0; i<tab.lenght;i++)
System.out.println("les éléments du tableau sont:"+tab[i]+ ", ");

Itération : for-each
for(String chaine : tab)
System.out.println("les éléments du tableau sont:"+chaine+ ", ");

Si besoin d’affichage des éléments du tableau tab:

int i=0;
for(String chaine : tab)
System.out.println("les éléments du tableau sont:"+chaine+ ", ");
i++;
67

34