Programmation Orientée Objet

Objets et Références en Java

Stack Heap
ref1 Objet A Objet B
ref2
ref3
Objet C

Auteur

Dr. BADR EL KHALYLY

Année Universitaire 2025-2026

Objets et Références Java Dr. BADR EL KHALYLY

Table des matières

1 Introduction aux Objets en Java 2

1.1 Caractéristiques Fondamentales . . . . . . . . . . . . . . . . . . . . . . . . 2

2 Types de Données en Java 3

2.1 Types Primitifs vs Types Références . . . . . . . . . . . . . . . . . . . . . 3
2.2 Architecture Mémoire : Stack vs Heap . . . . . . . . . . . . . . . . . . . . 3

3 Références en Java 4
3.1 Création et Affectation de Références . . . . . . . . . . . . . . . . . . . . . 4
3.2 Comparaison de Références : == vs equals() . . . . . . . . . . . . . . . . . 4

4 Cycle de Vie des Objets Java 5

4.1 Diagramme du Cycle de Vie Complet . . . . . . . . . . . . . . . . . . . . . 5
4.2 Étape 1 : Déclaration de la Référence . . . . . . . . . . . . . . . . . . . . . 5
4.3 Étape 2 : Création de l’Objet . . . . . . . . . . . . . . . . . . . . . . . . . 6
4.4 Étape 3 : Utilisation de l’Objet . . . . . . . . . . . . . . . . . . . . . . . . 6
4.5 Étape 4 : Perte de Référence - Objet Inaccessible . . . . . . . . . . . . . . 6
4.6 Étape 5 : Garbage Collection . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.6.1 La Méthode finalize() . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.7 Diagramme Temporel du Cycle de Vie . . . . . . . . . . . . . . . . . . . . 8

5 Shallow Copy vs Deep Copy (Objets Shadow) 8

5.1 Shallow Copy (Copie Superficielle) . . . . . . . . . . . . . . . . . . . . . . 9
5.2 Deep Copy (Copie Profonde) . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5.3 Comparaison Shallow vs Deep Copy . . . . . . . . . . . . . . . . . . . . . . 10
5.4 Schéma Comparatif Complet . . . . . . . . . . . . . . . . . . . . . . . . . . 11

6 Objets Immuables (Immutable Objects) 11

6.1 Avantages des Objets Immuables . . . . . . . . . . . . . . . . . . . . . . . 12

7 Références Faibles (Weak References) 12

8 Bonnes Pratiques 13

9 Exercices Pratiques 14
9.1 Exercice 1 : Analyse de Références . . . . . . . . . . . . . . . . . . . . . . 14
9.2 Exercice 2 : Implémenter Deep Copy . . . . . . . . . . . . . . . . . . . . . 14
9.3 Exercice 3 : Cycle de Vie . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

10 Conclusion 15

1
Objets et Références Java Dr. BADR EL KHALYLY

1 Introduction aux Objets en Java

Définition d’un Objet
En Java, un objet est une instance d’une classe. C’est une entité qui possède :
— Un état (attributs/propriétés)
— Un comportement (méthodes)
— Une identité (adresse mémoire unique)

1.1 Caractéristiques Fondamentales

Objets et Références Java Dr. BADR EL KHALYLY

2 Types de Données en Java

Java distingue deux catégories fondamentales de types de données :

2.1 Types Primitifs vs Types Références

Types Primitifs Types Références

byte, short, int, long Classes

float, double Interfaces

char Tableaux

boolean Enums

Table 1 – Comparaison Types Primitifs vs Types Références

Caractéristique Type Primitif Type Référence
Stockage Stack (valeur directe) Heap (via référence)
Valeur par défaut 0, false, ’\u0000’ null
Passage en paramètre Par valeur Par référence de valeur
Taille Fixe Variable
Peut être null Non Oui

2.2 Architecture Mémoire : Stack vs Heap

STACK HEAP
Frame : main()
int x 42 @0x1A2B @0x3C4D
double y 3.14 Personne Voiture

ref obj1 0x1A2B

ref obj2 0x3C4D
@0x5E6F
String
Caractéristiques :
- Accès LIFO Caractéristiques :
- Variables locales - Stockage des objets
- Références vers Heap - Gestion par Garbage Collector
- Taille limitée - Taille dynamique
- Partagé entre threads

3
 Objets et Références Java Dr. BADR EL KHALYLY

3 Références en Java
Référence
Une référence en Java est une variable qui contient l’adresse mémoire d’un objet
dans le Heap. Ce n’est PAS l’objet lui-même, mais un "pointeur" vers cet objet.

3.1 Création et Affectation de Références

1 // Declaration d ’ une reference ( initialisee a null )
2 Personne p1 ; // p1 = null
3

4 // Creation d ’ objet et affectation de reference

5 p1 = new Personne ( " Ali " , 30) ;
6

7 // Copie de reference ( PAS de l ’ objet !)

8 Personne p2 = p1 ; // p1 et p2 pointent vers le meme objet
9

10 // Modification via p2 affecte aussi p1

11 p2 . setAge (31) ;
12 System . out . println ( p1 . getAge () ) ; // Affiche 31!
Listing 2 – Manipulation des références

Avant : Personne p2 = p1; Après : Personne p2 = p1;

Stack Heap Stack Heap

p1 p1

p2 = null Personne p2 Personne

Piège Classique !
Quand on écrit Personne p2 = p1;, on copie la référence, pas l’objet ! Les deux
variables pointent vers le même objet en mémoire.

3.2 Comparaison de Références : == vs equals()

Opérateur == Méthode equals()
Compare les adresses mémoire
Compare le contenu des objets
(les références pointent-
(les objets ont-ils les mêmes valeurs ?)
elles vers le même objet ?)

p1 = 0xABC p1 = 0xABC
"Ali"
p2 = 0xABC
Objet p2 = 0xDEF
"Ali"

p1 == p2 → true [Link](p2) → true

4
 Objets et Références Java Dr. BADR EL KHALYLY

1 String s1 = new String ( " Bonjour " ) ;

2 String s2 = new String ( " Bonjour " ) ;
3

4 System . out . println ( s1 == s2 ) ; // false ( references differentes

)
5 System . out . println ( s1 . equals ( s2 ) ) ; // true ( meme contenu )
6

7 // Attention au String Pool !

8 String s3 = " Bonjour " ;
9 String s4 = " Bonjour " ;
10 System . out . println ( s3 == s4 ) ; // true ( meme reference dans le
pool )
Listing 3 – Différence entre == et equals()

4 Cycle de Vie des Objets Java

Le cycle de vie d’un objet Java comprend plusieurs étapes distinctes, de sa création
jusqu’à sa destruction par le Garbage Collector.

4.1 Diagramme du Cycle de Vie Complet

Type ref; new Type() [Link]()

new initialisation
Déclaration Création Utilisation

perte de
référence

Détruit Éligible au GC Inaccessible

finalize() marquage GC

GC Sweep GC Mark ref = null;

4.2 Étape 1 : Déclaration de la Référence

1 Personne p ; // Declaration seule - p vaut null
2 // Aucun objet n ’ est cree en memoire
Listing 4 – Phase de déclaration

Stack Heap
null
p = null (vide)

5
 Objets et Références Java Dr. BADR EL KHALYLY

4.3 Étape 2 : Création de l’Objet

L’opérateur new effectue les actions suivantes :
1. Allocation mémoire dans le Heap
2. Initialisation des attributs aux valeurs par défaut
3. Exécution du constructeur
4. Retour de la référence vers l’objet créé

1 p = new Personne ( " Fatima " , 28) ;

2

3 // Decomposition du processus :
4 // 1. Allocation memoire pour l ’ objet Personne
5 // 2. nom = null , age = 0 ( valeurs par defaut )
6 // 3. Execution du constructeur : nom = " Fatima " , age = 28
7 // 4. Adresse memoire retournee et stockee dans p
Listing 5 – Phase de création

Stack Heap
p = 0x7F3A Personne @0x7F3A
nom = "Fatima"
age = 28

4.4 Étape 3 : Utilisation de l’Objet

Durant cette phase, l’objet est activement utilisé via sa référence.
1 // Acces aux attributs
2 String nomPersonne = p . getNom () ;
3

4 // Appel de methodes
5 p . sePresenter () ;
6 p . anniversaire () ;
7

8 // L ’ objet reste accessible tant qu ’ au moins

9 // une reference active pointe vers lui
Listing 6 – Phase d’utilisation

4.5 Étape 4 : Perte de Référence - Objet Inaccessible

Un objet devient inaccessible quand plus aucune référence n’y pointe.
1 // Methode 1: Affectation a null
2 p = null ;
3

4 // Methode 2: Reassignation a un autre objet

5 p = new Personne ( " Omar " , 35) ; // L ’ ancien objet " Fatima " est perdu

6
 Objets et Références Java Dr. BADR EL KHALYLY

7 // Methode 3: Sortie de portee

8 public void methode () {
9 Personne local = new Personne ( " Temp " , 20) ;
10 // ... utilisation ...
11 } // " local " sort de portee , l ’ objet devient inaccessible
Listing 7 – Différentes façons de perdre une référence

Stack Heap
p = null
× Personne
(orphelin)

Objet éligible au
Garbage Collection

4.6 Étape 5 : Garbage Collection

Garbage Collector (GC)

Le Garbage Collector est un processus automatique de la JVM qui récupère

la mémoire occupée par les objets qui ne sont plus accessibles. Il fonctionne en
arrière-plan et libère le développeur de la gestion manuelle de la mémoire.

Algorithme Mark-and-Sweep
Phase 1 : Mark
GC Roots Phase 2 : Sweep
GC Roots

A B A B

C C
D Mémoire libérée
E

4.6.1 La Méthode finalize()

Deprecated depuis Java 9

La méthode finalize() est dépréciée depuis Java 9. Il est recommandé d’utiliser
try-with-resources ou Cleaner pour le nettoyage des ressources.

1 public class Ressource {

2 @Override
3 protected void finalize () throws Throwable {
4 try {

7
 Objets et Références Java Dr. BADR EL KHALYLY

5 // Nettoyage des ressources

6 System . out . println ( " Nettoyage avant destruction " ) ;
7 } finally {
8 super . finalize () ;
9 }
10 }
11 }
12

13 // Approche moderne recommandee

14 public class RessourceModerne implements AutoCloseable {
15 @Override
16 public void close () {
17 // Nettoyage explicite
18 }
19 }
Listing 8 – Exemple de finalize() (déprécié)

4.7 Diagramme Temporel du Cycle de Vie

ref = null Objet actif Éligible GC

Déclaration Création Utilisation Inaccessible GC

Temps
Type ref; new Type() [Link]() ref = null; finalize() +
libération

5 Shallow Copy vs Deep Copy (Objets Shadow)

Copie d’Objets
En Java, copier un objet peut se faire de deux manières :
— Shallow Copy (Copie superficielle) : Copie les références des objets imbri-
qués
— Deep Copy (Copie profonde) : Copie récursivement tous les objets imbri-
qués

8
 Objets et Références Java Dr. BADR EL KHALYLY

5.1 Shallow Copy (Copie Superficielle)

Shallow Copy

Original
id = 1
adresse →
Adresse (PARTAGÉE)
clone()
rue = "123 Main St"
Copie ville = "Rabat"
id = 1
adresse → Danger!
Modifier l’adresse via
la copie affecte l’original!

1 public class Personne implements Cloneable {

2 private String nom ;
3 private Adresse adresse ; // Objet imbrique
4

5 @Override
6 public Personne clone () throws Cl on e No tS up p or te dE x ce pt io n {
7 return ( Personne ) super . clone () ; // Shallow copy !
8 }
9 }
10

11 // Utilisation
12 Personne p1 = new Personne ( " Ali " , new Adresse ( " Rabat " ) ) ;
13 Personne p2 = p1 . clone () ;
14

15 // ATTENTION : p1 . adresse == p2 . adresse ( meme reference !)

16 p2 . getAdresse () . setVille ( " Casablanca " ) ;
17 System . out . println ( p1 . getAdresse () . getVille () ) ; // " Casablanca " -
MODIFIE !
Listing 9 – Implémentation de Shallow Copy

9
 Objets et Références Java Dr. BADR EL KHALYLY

5.2 Deep Copy (Copie Profonde)

Deep Copy

Original
id = 1 Adresse 1
adresse → ville = "Rabat"

Sécurisé!
Indépendants Chaque objet a sa
deep clone()
propre copie d’Adresse
Copie
id = 1 Adresse 2
adresse → ville = "Rabat"

1 public class Personne implements Cloneable {

2 private String nom ;
3 private Adresse adresse ;
4

5 // Methode 1: Clone manuel

6 @Override
7 public Personne clone () throws Cl on e No tS up p or te dE x ce pt io n {
8 Personne copie = ( Personne ) super . clone () ;
9 copie . adresse = this . adresse . clone () ; // Deep copy !
10 return copie ;
11 }
12

13 // Methode 2: Constructeur de copie

14 public Personne ( Personne autre ) {
15 this . nom = autre . nom ;
16 this . adresse = new Adresse ( autre . adresse ) ; // Deep copy !
17 }
18 }
19

20 // Utilisation
21 Personne p1 = new Personne ( " Ali " , new Adresse ( " Rabat " ) ) ;
22 Personne p2 = p1 . clone () ; // ou new Personne ( p1 )
23

24 // Maintenant les adresses sont independantes

25 p2 . getAdresse () . setVille ( " Casablanca " ) ;
26 System . out . println ( p1 . getAdresse () . getVille () ) ; // " Rabat " - NON
MODIFIE !
Listing 10 – Implémentation de Deep Copy

5.3 Comparaison Shallow vs Deep Copy

10
Objets et Références Java Dr. BADR EL KHALYLY

Table 2 – Shallow Copy vs Deep Copy

Aspect Shallow Copy Deep Copy
Objets imbriqués Références partagées Copies indépendantes
Performance Rapide Plus lent
Mémoire Économe Consomme plus
Sécurité Risque d’effets de bord Isolation complète
Implémentation Simple ([Link]()) Récursive (manuelle)
Cas d’utilisation Objets immuables Objets mutables

5.4 Schéma Comparatif Complet

Comparaison des Types de Copie

Copie de Référence Deep Copy
p2 = p1; p2 = [Link]();
p1 p2 p1 p2

Obj Obj1 Obj2

Ref1 Ref2
Objets complète-
Même objet partagé
ment indépendants
Shallow Copy
p2 = [Link]();
p1 p2

Obj1 Obj2

Ref

Objet interne partagé

6 Objets Immuables (Immutable Objects)

Objet Immuable
Un objet immuable est un objet dont l’état ne peut pas être modifié après sa créa-
tion. Les classes String, Integer, LocalDate sont des exemples d’objets immuables
en Java.

11
 Objets et Références Java Dr. BADR EL KHALYLY

6.1 Avantages des Objets Immuables

Thread-safe par nature

Pas de copie défensive nécessaire

Peuvent être mis en cache

Clés de HashMap fiables

Pas d’effets de bord

1 public final class Point { // final pour empecher l ’ heritage

2 private final int x ; // final pour empecher la modification
3 private final int y ;
4

5 public Point ( int x , int y ) {

6 this . x = x ;
7 this . y = y ;
8 }
9

10 public int getX () { return x ; }

11 public int getY () { return y ; }
12

13 // Pas de setters !
14

15 // Pour " modifier " , on cree un nouvel objet

16 public Point translate ( int dx , int dy ) {
17 return new Point ( this . x + dx , this . y + dy ) ;
18 }
19 }
Listing 11 – Création d’une classe immuable

7 Références Faibles (Weak References)

Java propose différents types de références pour contrôler l’éligibilité au GC :

12
 Objets et Références Java Dr. BADR EL KHALYLY

Hiérarchie des Types de Références

Strong Soft Weak Phantom

Référence normale GC si mémoire basse GC au prochain cycle Notification finalize

+ Fort + Faible

1 import java . lang . ref .*;

2

3 // Strong Reference ( normale )

4 Object strong = new Object () ;
5

6 // Soft Reference - GC quand memoire insuffisante

7 SoftReference < Object > soft = new SoftReference < >( new Object () ) ;
8

9 // Weak Reference - GC des que possible

10 WeakReference < Object > weak = new WeakReference < >( new Object () ) ;
11

12 // Phantom Reference - pour nettoyage post - GC

13 ReferenceQueue < Object > queue = new ReferenceQueue < >() ;
14 PhantomReference < Object > phantom = new PhantomReference < >(
15 new Object () , queue
16 );
17

18 // Recuperer l ’ objet ( peut etre null si GC )

19 Object obj = weak . get () ;
20 if ( obj != null ) {
21 // Utiliser l ’ objet
22 }
Listing 12 – Utilisation des références faibles

8 Bonnes Pratiques
Résumé des Bonnes Pratiques
1. Toujours utiliser equals() pour comparer le contenu des objets, ré-
servez == pour les références
2. Implémenter hashCode() si vous implémentez equals()
3. Préférer les objets immuables quand c’est possible
4. Utiliser Deep Copy pour les objets mutables contenant des références
5. Éviter finalize() - utiliser try-with-resources
6. Mettre à null les références inutilisées dans les longues méthodes pour
aider le GC
7. Utiliser les références faibles pour les caches

13
 Objets et Références Java Dr. BADR EL KHALYLY

8. Ne jamais retourner de références mutables depuis des getters

9 Exercices Pratiques
9.1 Exercice 1 : Analyse de Références
1 String a = " Hello " ;
2 String b = " Hello " ;
3 String c = new String ( " Hello " ) ;
4

5 System . out . println ( a == b ) ; // ?

6 System . out . println ( a == c ) ; // ?
7 System . out . println ( a . equals ( c ) ) ; // ?
Listing 13 – Que va afficher ce code?

9.2 Exercice 2 : Implémenter Deep Copy

Implémentez une méthode de copie profonde pour la classe suivante :
1 public class Etudiant {
2 private String nom ;
3 private List < Cours > cours ;
4

5 // Implementer deepCopy ()
6 }
7

8 public class Cours {

9 private String titre ;
10 private Professeur prof ;
11 }
Listing 14 – Classe à copier

9.3 Exercice 3 : Cycle de Vie

Dessinez le diagramme mémoire (Stack/Heap) pour chaque étape du code suivant :
1 public void exemple () {
2 Personne p1 = new Personne ( " A " ) ;
3 Personne p2 = new Personne ( " B " ) ;
4 p1 = p2 ;
5 p2 = null ;
6 p1 = null ;
7 }
Listing 15 – Tracer le cycle de vie

14
Objets et Références Java Dr. BADR EL KHALYLY

10 Conclusion
La maîtrise des objets et références en Java est fondamentale pour :
— Écrire du code correct et sans bugs subtils
— Optimiser l’utilisation de la mémoire
— Comprendre le comportement du Garbage Collector
— Éviter les fuites de mémoire
— Implémenter correctement la copie d’objets

Points Clés à Retenir

• Les variables références ne sont pas les objets
• == compare les références, equals() le contenu
• Le GC gère automatiquement la mémoire
• Shallow Copy partage les objets imbriqués
• Les objets immuables sont thread-safe

Dr. BADR EL KHALYLY

Cours de Programmation Orientée Objet - Java

15