POO en java

Pr. AIT MAIT Hind

2025/2026
C h api tre 1

Introduction au Java
Introduction

Caractéristiques du langage java

• Orienté objet: Java repose sur le paradigme de la programmation orientée objet (POO).

• Portable: Grâce à la machine virtuelle Java (JVM), le code Java peut s’exécuter sur différentes plateformes
("Write Once, Run Anywhere").

• Sécurisé: Java propose des fonctionnalités avancées pour la gestion de la sécurité et la protection des applications.

• Multithreading: Java permet l’exécution simultanée de plusieurs threads, optimisant ainsi la performance.

POO en java 1
Introduction
Mode d’exécution

POO en java 2
Introduction

Pourquoi Java?

L’API de Java
• Java fournit de nombreuses librairies de classes remplissant des fonctionnalités très diverses: c’est l’API Java.
• API (Application and Programming Interface /Interface pour la programmation d’applications): Ensemble de
bibliothèques permettant une programmation plus aisée.

• Ces classes sont regroupées par catégories en paquetages (ou "packages").

POO en java 3
Introduction
Pourquoi Java?

L’API de Java
Les principaux paquetages:
• [Link] : structures de données classiques.
• [Link]: entrées / sorties.
• [Link] : chaînes de caractères, interaction avec l’OS, threads.
• [Link] : les applets sur le web.
• [Link] : interfaces graphiques, images et dessins...
• [Link] : package récent proposant des composants « légers» pour la création d’interfaces graphiques.
• [Link] : sockets, URL ...
• [Link] : Remote Method Invocation.
• [Link] : fournit le package JDBC.

POO en java 4
Introduction

Outil de développement: le JDK

• JDK signifie Java Development Kit (Kit de développement Java).

• Il contient:
◦ les classes de base de l’API java,
◦ le compilateur: javac,
◦ la JVM (machine virtuelle): java,
◦ le générateur de documentation au format HTML : javadoc.

POO en java 5
C h api tre 2

Structures fondamentales
Syntaxe du langage Java

Les commentaires (1)

• /* commentaire sur une ou plusieurs lignes */

• // commentaire de fin de ligne
• /** commentaire d’explication */

• Les commentaires d’explication se placent généralement juste avant une déclaration (d’attribut ou de
méthode).
• Ils sont récupérés par l’utilitaire javadoc et inclus dans la documentation ainsi générée.

6
Syntaxe du langage Java

Les commentaires (2)

/** Classe Calculatrice

* Classe simple pour effectuer une addition de deux nombres. Description :
* @author Hind Classe simple pour effectuer une addition de
* @version 1.0 deux nombres.
*/ Author : Hind
public class Calculatrice { Version : 1.0
javadoc [Link]
/** Méthode Description
* Calcule la somme de deux entiers. Calcule la somme
* @param a premier entier de deux entiers.
* @param b second entier Paramètres : a –
* @return la somme de a et b int addition(int a, premier entier
*/ int b) b – second
public int addition(int a, int b) Entier
{ return a + b; Retourne : la
} somme de a et b
}

7
Syntaxe du langage Java

Instructions, blocs et blancs

• Les instructions Java se terminent par un ;

• Les blocs sont délimités par :
◦ {pour le début de bloc.
◦ } pour la fin du bloc.
• Un bloc permet de définir un regroupement d’instructions. La définition d’une classe ou d’une méthode se fait
dans un bloc.

• Les espaces, tabulations, sauts de ligne sont autorisés. Cela permet de présenter un code plus lisible.

8
Syntaxe du langage Java

Point d’entrée d’un programme Java

• Pour pouvoir faire un programme exécutable il faut toujours une classe qui contienne la méthode "main"
• C’est le point d’entrée dans le programme: le microprocesseur sait qu’il va commencer à exécuter les instructions à
partir de cet endroit.

public static void main(String[] args) {

...
}

9
Syntaxe du langage Java

Identificateurs
• On a besoin de nommer les classes, les variables, les constantes, etc. ;
on parle d’identificateur. (Attention: Java distingue les majuscules des minuscules.)
Type d'identificateur Exemple valide Remarques
Commence par une lettre
Nom de classe MaClasse
majuscule (convention).
Commence par une lettre
Nom de méthode calculerValeur
minuscule (convention).
Nom de variable compteur Commence par une lettre.
Commence par le caractère
Nom de variable _temperature
de soulignement (_).
Commence par le signe
Nom de variable $montantFinal
dollar ($).
Peut contenir des chiffres
Nom de variable i18n
(sauf en première position).

Nom de constante MAXI En majuscules(convention).

POO en java 10
Syntaxe du langage Java

Affectation

§ L'affectation est l'opération qui consiste à donner une valeur à un identificateur (variable ou constante)
que l'on a préalablement déclaré.

• Elle utilise le symbole de l'égalité simple (=).

• La variable (ou l'identificateur) est toujours placée à gauche du signe =.
• La valeur ou l'expression est toujours placée à droite du signe =.

int compteur = 0;
compteur= 5; // C'est permis
Exemple:
final int NOMBRE_JOURS = 7; // NOMBRE_JOURS = 8; // <-- C'est interdit, cause une erreur de
compilation!

POO en java 11
Syntaxe du langage Java

Écriture en Java

L’écriture sur l’écran se fait à l’aide de l’objet [Link] et de ses méthodes principales:

• [Link](): Affiche le texte sans retour à la ligne.

Exemple: [Link]("Bonjour ");

[Link]("tout le monde !");

• [Link](): Affiche le texte suivi d’un saut de ligne.

[Link]("Bonjour");
Exemple:
[Link]("tout le monde !");

• [Link](): Permet d’afficher du texte formaté, similaire à printf en langage C.

int age = 20;

Exemple:
[Link]("J'ai %d ans.", age);

POO en java 12
Syntaxe du langage Java

Lecture en Java
§ Pour lire des données saisies par l’utilisateur, on utilise la classe Scanner, appartenant au paquetage
[Link].
Ø Avant d’utiliser Scanner, il faut l’importer: import [Link];
Ø Création d’un objet Scanner: Scanner sc = new Scanner([Link]);

import [Link];
public class Lecture {
public static void main(String[] args) {
Exemple: Scanner scanner = new Scanner([Link]);
[Link]("Entrez votre nom : ");
String nom = [Link]();
[Link]("Bonjour, " + nom + " !");
[Link]();
}
}

POO en java 13
Syntaxe du langage Java

Les types de bases

• En Java, tout est objet sauf les types de base.

• Il y a 8 types de base :
◦ un type booléen pour représenter les variables ne pouvant prendre que 2 valeurs (vrai et faux, 0 ou 1, etc.) : boolean
avec les valeurs associées true et false.
◦ un type pour représenter les caractères: char.
◦ quatre types pour représenter les entiers de divers taille : byte, short, int et long.
◦ deux types pour représenter les réelles : float et double.

POO en java 14
Syntaxe du langage Java

Les opérateurs

Les opérateurs Java sont des symboles spéciaux qui effectuent des opérations sur les variables et les
valeurs. Ils sont utilisés pour manipuler les données et les variables dans les expressions. Java propose un
large éventail d'opérateurs classés en plusieurs types en fonction de leur fonctionnalité.

§ Opérateurs arithmétiques
+ (Ajout)
int a = 10;
- (Soustraction)
int b = 5;
* (Multiplication) [Link]("Addition: " + (a + b)); // Output: 15
/ (Division) [Link]("Subtraction: " + (a - b)); // Output: 5
[Link]("Multiplication: " + (a * b));// Output: 50
% (module)
[Link]("Division: " + (a / b)); // Output: 2
[Link]("Modulus: " + (a % b)); // Output: 0

POO en java 15
Syntaxe du langage Java

Les opérateurs
§ Opérateurs relationnels
== (égal à)
int a = 10;
!= (non égal à)
int b = 5;
> (Supérieur à) [Link](a == b); // Output: false
< (moins de) [Link](a > b); // Output: true
[Link](a < b); // Output: false
>= (supérieur ou égal)
<= (Inférieur ou égal à)

§ Opérateurs logiques
boolean x = true;
&& (ET logique)
boolean y = false;
|| (OU logique) [Link](x && y); // Output: false
! (logique NOT) [Link](x || y); // Output: true
[Link](!x); // Output: false

POO en java 16
Syntaxe du langage Java

Les opérateurs

§ Opérateurs d’assignation
+= (Ajouter et attribuer)
-= (Soustraire et céder)
*= (Multiplier et attribuer) int a = 10;
a += 5; // Equivalent to a = a + 5
/= (Diviser pour mieux régner)
[Link](a); // Output: 15
%= (Modulus et assign)

§ Opérateurs d’incrémentation
++ (Incrément)
-- (Diminution) int a = 10;
[Link](++a); // Output: 11
[Link](--a); // Output: 10

POO en java 17
Les structures conditionnelles

Instructions conditionnelles

• Effectuer une ou plusieurs instructions seulement si une certaine condition est vérifiée.
if (condition){
//bloc d'instructions
}
• Effectuer une ou plusieurs instructions si une certaine condition est vérifiée sinon effectuer d’autres instructions.
if (condition) {
//1er bloc d'instructions
}
else {
//2ème bloc d'instructions
}

POO en java 18
Les structures conditionnelles

Instructions conditionnelles

import [Link];
public class Comparaison {
public static void main(String[] args) {
Scanner sc = new Scanner([Link]); // Création de l’objet Scanner
[Link]("Entrez le premier entier (a) : ");
§ Exemple int a = [Link](); // Lecture du premier entier
[Link]("Entrez le deuxième entier (b) : ");
int b = [Link](); // Lecture du deuxième entier
if (a > b)
[Link]("Le plus grand est : " + a);
else
[Link]("Le plus grand est : " + b);

[Link](); // Fermeture du Scanner

}
}

POO en java 19
Les structures conditionnelles

Instructions conditionnelles
§ switch
• L’utilisation de if / else peut s’avérer lourde quand on doit
traiter plusieurs sélections et de multiples alternatives. switch(nb)
{
• pour cela existe en Java le switch / case assez identique à
case 1:
celui de C/C++ . [Link]("Un");
break;
• La valeur sur laquelle on teste doit être un char ou un case 2:
entier. [Link]("Deux");
break;
• L’exécution des instructions correspondant à une default:
alternative commence au niveau du case correspondant et se [Link]("Autrenombre");
break;
termine à la rencontre d’une instruction break ou arrivée à la
}
fin du switch.

POO en java 20
Les structures répétitives

Les structures répétitives

• On veut répéter une ou plusieurs instructions un nombre indéterminés de fois: on répète l’instruction ou le bloc
d’instruction tant que une certaine condition reste vraie.
• nous avons en Java une première boucle while:

import [Link];
• while (condition) public class Factorielle {
public static void main(String[] args) {
{ Scanner sc = new Scanner([Link]);
//bloc d'instructions [Link]("Entrer n: ");
int n = [Link]();
} int result = 1, i = n;
while (i > 1) {
result = result * i;
i--; }
[Link]("La factorielle de " + n + " vaut " + result);
[Link]();}}

POO en java 21
Les structures répétitives

Les structures répétitives

• Un autre type de boucle:

• do (condition) { int i = 0;
//bloc d'instructions do {
}while (condition); [Link](i);
i++;
}while (i < 5);

POO en java 22
Les structures répétitives

Les structures répétitives

Boucle déterminée : "for"

• On veut répéter une ou plusieurs instructions un nombre déterminés de fois : on répète l’instruction ou le
bloc d’instructions pour un certain nombre de pas.
for (int i = 1; i <= 10; i++)

{
[Link](i);
}

POO en java 23
Les structures répétitives

Les structures répétitives

Boucle déterminée : "for each"
• for-each (aussi appelé enhanced for loop) est une version simplifiée de la boucle for qui permet d’itérer directement
sur les éléments d’un tableau ou d’une collection (par exemple, ArrayList, HashSet, etc.) sans avoir à gérer un
compteur ou un index.

• Syntaxe générale:
for (Type element : collectionOuTableau) {
// Instructions utilisant 'element'
}

Ø Type : le type des éléments contenus dans la collection ou le tableau.

Ø Elément : variable temporaire qui prend successivement la valeur de chaque élément.
Ø collection Ou Tableau : tableau ou objet qui implémente l’interface Iterable (par ex. ArrayList, HashSet, etc.).

POO en java 24
Les structures répétitives

Les structures répétitives

Boucle déterminée : “for each”

§ Exemple:

public static void main(String[] args){

int collection[] = {10, 20, 30, 40, 50}
for (int value : collection){
[Link](value);
}
}

POO en java 25
C h api tre 3

Tableaux
Les tableaux

Les tableaux
§ Les tableaux permettent de stocker plusieurs valeurs de même type.
◦ Les valeurs contenues dans la variable sont repérées par un indice.
◦ Les tableaux sont des objets
§ Déclaration : (Type [] nomTableau ;).
Exemple: int notes[];
int[] notes; // forme recommandée en Java
§ Création du tableau
notes = new int[5]; // crée un tableau de 5 entiers initialisés à 0
§ Déclaration + création en une seule ligne
int[] notes = new int[5];
Ø ou bien, avec initialisation directe: int[] notes = {12, 15, 18, 10, 14};

26
Les tableaux

Les tableaux: Opérations de Base

§ Parcourir un tableau
• Pour parcourir un tableau, on utilise l’instruction "for"

Méthode 1:
public class Demo {
public static void main( String [] args ) {
// Déclaration et initialisation du tableau
int array [] = { 10, 20, 30, 40, 50 };
// Parcours du tableau
for ( int i=0; i<[Link];i++ ) {
[Link]( array[ i ] );
}
}
}

27
Les tableaux

Les tableaux: Opérations de Base

§ Parcours avec un for each

Méthode 2:
public class Demo {
public static void main( String [] args ) {
// Declaration et initialisation du tableau
int array[] = { 10, 20, 30, 40, 50 };
[Link]( "Parcours du tableau avec un for each" );
for ( int value : array ) {
[Link]( value );
}
}
}

POO en java 28
Les tableaux

Les tableaux: Opérations de Base

§ Accéder à un élément

int[] notes = {12, 15, 18, 10, 14};

// Afficher le premier élément
Exemple:
[Link](notes[0]); // Résultat : 12
// Afficher le troisième élément
[Link](notes[2]); // Résultat : 18

§ Modifie un élément notes[1] = 20; // Remplace 15 par 20

notes[3] = 11; // Remplace 10 par 11

§ Obtenir la Longueur
int longueur = [Link];

POO en java 29
Les tableaux

Arrays en java

§ Les tableaux offrent les opérations essentielles:

• accès à un élément,
• modification,
• calcul de la longueur.
§ Si l’on veut par exemple :
• trier un tableau,
• le copier,
• le comparer,
Ø Il serait fastidieux de tout réécrire à chaque fois.
Ø Pour simplifier ces manipulations, Java fournit une classe utilitaire appelée Arrays, qui contient de
nombreuses méthodes prêtes à l’emploi pour travailler efficacement avec les tableaux.

POO en java 30
Les tableaux

Arrays en java

§ [Link]() → Afficher le contenu d’un tableau

import [Link];
int[] notes = {12, 8, 15, 10, 18}; [12, 8, 15, 10, 18]

[Link]([Link](notes));

§ [Link]() → Remplir un tableau avec une même valeur

import [Link];
int[] tab = new int[5]; [7, 7, 7, 7, 7]
[Link](tab, 7); // Remplit tout le tableau avec 7
[Link]([Link](tab));

POO en java 31
Les tableaux

Arrays en java
§ [Link]() → Trier un tableau en ordre croissant

import [Link];
int[] valeurs = {5, 2, 8, 1, 3}; [1, 2, 3, 5, 8]
[Link](valeurs);
[Link]([Link](valeurs));

§ [Link]() → Comparer deux tableaux

import [Link];
int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
int[] c = {3, 2, 1};
[Link]([Link](a, b)); // true
[Link]([Link](a, c)); // false

POO en java 32
Les tableaux

§ Exercice d’application:

§ Écrire un programme Java qui:

• Demande à l’utilisateur de saisir les 5 valeurs du tableau A.
• Demande à l’utilisateur de saisir les 4 valeurs du tableau B.
• Fusionne les deux tableaux dans un troisième tableau C, de manière à ce que C contienne
tous les éléments de A suivis de ceux de B.

§ Affiche à la fin:
• le contenu du tableau A,
• le contenu du tableau B,
• et le contenu du tableau C après la fusion.

POO en java 33
Les tableaux

§ Exercice d’application: Solution // Étape 2 : Déclaration et saisie du tableau B

int[] B = new int[4];
import [Link]; [Link]("\n--- Saisie du tableau B ---");
import [Link]; for (int i = 0; i < [Link]; i++) {
public class FusionTableauxSaisie { [Link]("Entrez la valeur " + (i + 1) + " : ");
public static void main(String[] args) { B[i] = [Link]();
Scanner sc = new Scanner([Link]); }
// Étape 1 : Déclaration et saisie du tableau A // Étape 3 : Création du tableau C pour la fusion
int[] A = new int[5]; int[] C = new int[[Link] + [Link]];
[Link]("--- Saisie du tableau A ---"); // Copier les éléments du tableau A dans C
for (int i = 0; i < [Link]; i++) { for (int i = 0; i < [Link]; i++) {
[Link]("Entrez la valeur " + (i + 1) + " : "); C[i] = A[i];}
A[i] = [Link]();
}

POO en java 34
Les tableaux

§ Exercice d’application: Solution (suite)

// Copier les éléments du tableau B dans C à la suite de A

for (int i = 0; i < [Link]; i++) {

C[[Link] + i] = B[i];
}
// Étape 4 : Affichage des trois tableaux
[Link]("Tableau A : " + [Link](A));
[Link]("Tableau B : " + [Link](B));
[Link]("Tableau C (fusionné) : " + [Link](C));
[Link]();
}
}

POO en java 35
C h api tre 4

Matrices
Les matrices

Matrices
§ Vu comme une grille composée de lignes et de colonnes,
§ Chaque élément est désigné par sa position dans cette grille : (numéro de ligne, numéro de colonne),
§ Si T est un tableau à deux dimensions, l’élément à la ligne i et colonne j est donné par T[i][j].

POO en java 36
Les matrices

Matrices

§ Déclaration : (Type [][] nomMatrice;).

Exemple:int notes[][];
int[][]notes; // forme recommandée en Java
§ Création du tableau
notes = new int[3][4]; // crée une matrice de 3 lignes et 4 colonnes
§ Déclaration + création en une seule ligne
int[][] notes = new int[3][4];
ou bien, avec initialisation directe: int[][] notes = {{12, 15, 18, 10},{14, 16, 11, 13},{9, 17,
15, 14}};

POO en java 37
Les matrices

Représentation de matrices en mémoire

§ Une matrice est en réalité un tableau de tableaux.
§ Exemple : int[][] t = new int[3][4] est formé de 3 tableaux de int, où chacun de ces 3 tableaux a 4
composantes de type int.

POO en java 38
Les tableaux

Les Marices: Opérations de Base

§ Parcourir une matrice
• Pour parcourir une matrice, on utilise généralement deux boucles for imbriquées.
• Le nombre de lignes est donné par: [Link]
• Le nombre de colonnes est donné par: matrice[i].length

Méthode 1:
public class Demo {
public static void main( String [] args ) {
// Déclaration et initialisation de la matrice
int[][] M = {{10, 20, 30},{40, 50, 60}};
// Parcours de la matrice
for (int i = 0; i < [Link]; i++) {
for (int j = 0; j < M[i].length; j++) {
[Link](M[i][j]);
} }}}

39
Les matrices

Les matrices: Opérations de Base

§ Parcours avec un for each
§ Une matrice est un tableau de tableaux.
§ La boucle for-each permet de parcourir:
• chaque ligne de la matrice,
• puis chaque élément de la ligne.

Méthode 2:
public class Demo {
public static void main( String [] args ) {
// Déclaration et initialisation de la matrice
int[][] M = {{10, 20, 30},{40, 50, 60}};
// Parcours de la matrice avec for-each
for (int[] ligne : M) { // parcours des lignes
for (int valeur : ligne) { // parcours des colonnes
[Link](valeur);
}}}}

POO en java 40
Les matrices

Les matrices: Opérations de Base

§ Accéder à un élément

int[][] notes = {{12, 15, 18, 10},{14, 16, 11, 13}};

Exemple:
[Link](notes[0][0]); // Résultat : 12

[Link](notes[0][2]); // Résultat : 18

§ Modifie un élément notes[0][1] = 20; // Remplace 15 par 20

notes[1][3] = 11; // Remplace 13 par 11

POO en java 41
C h api tre 5

ClasseString
Classe String

String: Définition

Une chaîne de caractères en Java est un objet de la classe String qui représente une suite de caractères.
Elle est immutable, c’est-à-dire que son contenu ne peut pas être modifié après sa création.

String s = "Hind"; String s = "Hind";

Exemple:
[Link](); s =[Link]();

[Link](s); [Link](s);

POO en java 42
Classe String

String: Manipulation

1. Déclaration: String indentifiant

2. Création d’une chaine: String s = "Hind"; ou bien String s = new String("Hind");

3. Longueur d’une chaîne:

String s = "Java";
int longueur = [Link]();
[Link](longueur); //4

4. Concaténation avec l’opérateur +

String prenom = "Hind";
String message = "Bonjour " + prenom;
[Link](message);// Bonjour Hind

POO en java 43
Classe String

String: Manipulation

5. Concaténation avec la méthode concat()

String s1 = "Bonjour ";

String s2 = "Hind";
String resultat = [Link](s2);
[Link](resultat); //Bonjour Hind

6. Vérification si une sous-chaîne existe.

String s = "Java Programming";

boolean test = [Link]("Java");

[Link](test);// true

POO en java 44
Classe String

String: Manipulation
7. Recherche un caractère ou une sous-chaîne (indice)

String s = "Java Programming"; String s = "Java Programming";

int pos = [Link]('a'); int pos = [Link]("Pro");
[Link](pos);//1 [Link](pos);//5

8. Vérification si la chaîne n’est pas nulle et ce n’est pas vide.

String s = " ";

if (s != null && ![Link]()) {
[Link]([Link]()); // false
[Link]("Chaîne valide");}
[Link]([Link]().isEmpty()); // true

POO en java 45
Classe String

String: Manipulation
9. Comparaison des chaînes de caractères en Java: == (Référence)

String a = "Java";
String a = new String("Java");
String b = "Java";
String b = new String("Java");
[Link](a == b); // true
[Link](a == b); // false

10. Comparaison des chaînes de caractères en Java: equals(Contenu)

String a = "Java";
String b = "JAVA";
[Link]([Link](b)); // false
[Link]([Link](b)); // true

POO en java 46
Classes et Objets
Pr. AIT MAIT Hind

2025/2026
Introduction

§Paradigme de programmation: est une façon d’organiser le code pour résoudre un problème. Chaque
paradigme propose une vision différente:
Comment représenter les données,
Comment structurer les instructions,
Comment décomposer et résoudre les problèmes.
ØParmi les paradigmes de programmation, on trouve:
Programmation procédurale,
Programmation orientée objet.

POO en java 1
Introduction

§ Programmation procédurale
Ø Le programme est divisé en petites parties appelées procédures /fonctions qui effectuent des
traitements sur des données.
Ø Il n’existe pas un lien direct entre les données et les traitements.
• Les données et les traitements sont séparés.
• Les données à traiter sont passées en arguments aux procédures

POO en java 2
Introduction

§ Programmation Orientée Objet

ØLe programme est composé de plusieurs objets qui contiennent:
• des données « internes »,
• des traitement qui manipulent ces données internes ou d’autres données.
ØLes données et leurs traitements sont regroupés dans une seule entité: objet.

POO en java 4
Introduction

§ Programmation Orientée Objet

ØLes données d’un objet sont appelés ses attributs.
ØLes traitements d’un objet sont appelés ses méthodes.

POO en java 5
Introduction

§ Programmation Orientée Objet

ØLa plupart des langages de programmation populaires aujourd’hui sont basés sur l’approche
objets. Mais les objets ne sont pas uniquement utilisés pour la programmation...

qBases de données objets(Oracle)

q Méthodes de conception objets (UML)

POO en java 6
Introduction

POO en java 7
Objet & Classe

Notion d’objet

Ø Le concept d’objet est utilisé pour modéliser informatiquement des objets concrets de la vie
courante (véhicule, personne, etc.) ou des objets conceptuels (date, etc.).

POO en java 8
Classe & Objet

Notion d’objet

qUn objet est une entité informatique comprenant:

• des données membres (ou champs/attributs)
• des fonctions membres (ou méthodes)

qUn objet possède un état:

L’état est donné par la valeur de ses attributs à un instant donné.
Il peut varier au cours du temps.

qUn objet possède une identité:

qui permet de le distinguer des autres objets indépendamment de son état,
qui est construite grâce à un identifiant

POO en java 9
Objet & Classe

Notion de classe

Ø Une classe est la description d’une famille d’objets ayant une même structure et un même
comportement.

POO en java 10
Classe & Objet

Notion de classe

q Une classe est un type de données défini par l'utilisateur,

q Une classe est comme un modèle pour un objet.

q Une classe d’un objet décrira donc:

-Des données membres.
-Des méthodes membres qui seront des fonctions

Ø Les membres d’une classe sont accessibles et utilisables en créant une instance de cette
classe.

POO en java 11
Classe & Objet

Objet et classe: Instanciation

§ Pour désigner un objet de la

classe, on dit aussi une
instance.
§ L'instanciation est le
mécanisme de création
d'objets à partir d'une
classe.
§ Une classe peut être réutilisée
pour instancier plusieurs
objets.

POO en java 12
Classe & Objet

Syntaxe de définition d’une classe

modificateurs class nom_de_classe
{
...
}
n Exemple:
public class Point {
// 1. Attributs (coordonnées du point)
private int x;
private int y;
// 2. Constructeur (pour initialiser le point)
public Point(int abs, int ord) {
x = abs;
y = ord;
}
// 3. Méthode pour déplacer le point
public void deplacer(int dx, int dy) {
x = x + dx;
y = y + dy;
}}

POO en java 13
Classe & Objet

Modificateurs de la classe

Modificateur Rôle
La classe contient une ou des méthodes abstraites, qui n'ont pas de définition
explicite. Une classe déclarée abstract ne peut pas être instanciée : il faut définir
abstract une classe qui hérite de cette classe et qui implémente les méthodes nécessaires
pour ne plus être abstraite.

La classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage est

final interdite. Les classes déclarées final ne peuvent donc pas avoir de classes filles.

private La classe n'est accessible qu'à partir de la classe où elle est définie (les classes
internes).
public La classe est accessible partout

POO en java 14
Classe & Objet

Objet

n La classe est la description d'un objet.

n Un objet est une instance d'une classe.

n L'opérateur new crée une instance d'une classe en faisant appel à une méthode
particulière appelée constructeur, et renvoie une référence sur l'objet instancié.
n Pour chaque instance d'une classe, le code est le même, seules les données sont
différentes à chaque objet.

POO en java 15
Classe & Objet

La création d’un Objet

n Il est nécessaire de déclarer une variable ayant le type de l'objet désiré.

q La déclaration est de la forme: <nomClasse> <variable>;
q Exemple: Point a;

q Contrairement à la déclaration d’une variable d’un type primitif (comme int n ;),
elle ne réserve pas d’emplacement pour un objet de type Point, mais seulement
un emplacement pour une référence à un objet de type Point.

n L’emplacement pour l’objet proprement dit sera alloué sur une demande explicite
du programme, en faisant appel à l’opérateur unaire nommé new.

POO en java 16
Classe & Objet

La création d’un Objet

n L'opérateur new se charge de créer une instance de la classe et de l'associer à la

variable (place sa référence dans variable):
q<variable> = new <nomClasse>(<paramètres>) ;

qExemple: Point a = new Point(3,5); // crée un objet de type Point et place sa

référence dans a.

q Les valeur de x et y sont initialisées ici à 3 et 5.

POO en java 17
Classe & Objet

Initialisation d’un objet

n Les attributs d’un objet sont toujours initialisés par défaut.

n Dès qu’un objet est créé, et avant l’appel du constructeur, ses attributs sont initialisés à
une valeur par défaut ainsi définie:
Type du champ Valeur par défaut Explication
boolean false Par défaut, faux.
char '\u0000' (caractère vide) Représente un caractère nul
byte, short, int, long 0 Tous les entiers valent 0.
float, double 0.0 Tous les nombres réels valent 0.0.
Aucune référence : l’attribut ne
objet (ex : String, Point, etc.) null
pointe vers aucun objet.

POO en java 18
Encapsulation

Encapsulation

n L’accès direct aux variables d'un objet est possible en JAVA

n MAIS ... n'est pas recommandé car contraire au principe d'encapsulation

q les données d'un objet doivent être privées (c'est à dire protégées et accessibles(et surtout
modifiables) qu'au travers de méthodes prévues à cet effet).

n Plusieurs niveaux de visibilité peuvent être définis en précédant la déclaration de chaque

attribut ou méthode d’un modificateur (private, public, protected)

POO en java 19
Encapsulation

Les modificateurs d'accès

public protected private

Attribut accessible Attribut accessible dans Attribut accessible
Attributs depuis code de les classes filles et uniquement dans le code de
n’importe quelle classes du même la classe qui le définit
classe. package.
Méthode pouvant être Méthode pouvant être L'usage de la méthode est
Méthode invoquée depuis invoquée dans les réservé aux méthodes de la
n’importe quelle classes filles et classes même classe.
classe. du même package.

Sans modificateur, une entité (méthode ou attribut) est visible par toutes les classes se trouvant
dans le même package.

POO en java 20
Constructeurs

Constructeurs

§ Un constructeur est une méthode spéciale d’une classe qui est appelée automatiquement
lors de la création d’un objet.
§ Porte le même nom que la classe.
§ Ne retourne aucune valeur (pas même void).
§ Peut être surchargé (plusieurs constructeurs avec des paramètres différents).
§ Est appelé automatiquement par new.

POO en java 21
Constructeurs

Constructeur Par défaut

§ C’est un constructeur sans paramètre.

§ Il est créé automatiquement par le compilateur si aucun autre constructeur n’est
défini.
public class Point {
// Attributs (coordonnées du point)
private int x;
private int y;
// Constructeur par défaut
public Point() {
x = 0;
y = 0;
}
}
Ø Point p = new Point(); // appel automatique du constructeur par
défaut

POO en java 22
Constructeurs

Constructeur paramétré

§ Il sert à initialiser les attributs de l’objet avec des valeurs données lors de sa
création.
public class Point
{
// Attributs (coordonnées du point)
private int x;
private int y;
// Constructeur paramétré
public Point(int abs, int ord) {
x = abs;
y = ord;
}
}
Ø Point p = new Point(3, 5); // initialise x=3, y=5

POO en java 23
Constructeurs

Constructeur de copie (1)

§ Le constructeur de copie permet de créer un nouvel objet à partir d’un autre objet du
même type. Autrement dit, il duplique les attributs d’un objet existant.
public class Point
{
private int x, y;
// Constructeur paramétré
public Point(int abs, int ord) {
x = abs;
y = ord;
}
public Point(Point p) {
this.x = p.x;
this.y = p.y;
}
}

POO en java 24
Constructeurs

Constructeur de copie (2)

§ Utilisation:
public class TestPoint {
public static void main(String[] args) {
Point p1 = new Point(3, 4);
Point p2 = new Point(p1); // création par copie

[Link](); // (3, 4)
[Link](); // (3, 4)
}
}

POO en java 25
Constructeurs

Constructeur de copie (2)

§ Utilisation:
public class TestPoint {
public static void main(String[] args) {
Point p1 = new Point(3, 4);
Point p2 = new Point(p1); // création par copie

[Link](); // (3, 4)
[Link](); // (3, 4)
}
}

POO en java 26
Destructeur

Destruction d’objets (1)

§ Java n’a pas prévu la notion de destructeur telle quelle en existe en C++.
§ La destruction des références d’objets se fait automatiquement grâce à un processus
appelé "ramasse miettes" (ou garbage collector) qui s’occupe de collecter les objets qui
ne sont plus référenciés.

POO en java 27
Destructeur

Destruction d’objets (2)

§ Exemple (C++ vs JAVA) class Personne {
private String nom;
class Personne { public Personne(String n) {
private: nom = n;
string nom; [Link]("Constructeur : " + nom + "
public: (objet créé)");
Personne(string n) { }
nom = n; } public void afficher() {
~Personne() { // Destructeur [Link]("Bonjour, je suis " + nom);
cout << "Destructeur : " << nom << endl; }}
} }; public class Test {
int main() { public static void main(String[] args) {
Personne* p = new Personne("Ali"); Personne p = new Personne("Ali");
cout << "Programme en cours..." << endl; [Link]();
delete p; p = null;
cout << "Fin du programme" << endl; } [Link]("Fin du programme");}}

POO en java 28
Variable d’instance vs de la classe

Variables d’instance

n Une variable d'instance nécessite simplement une déclaration de la variable dans

le corps de la classe.

public class MaClasse {

private int valeur1, valeur2 ;
protected int valeur3 ;
private Point valeur4 ;
}

n Chaque objet de la classe possède sa propre copie de ces variables.

n Cela permet de différencier un objet d’un autre.

POO en java 29
Variable d’instance vs de la classe

Variable de la classe

n La variable de la classe est définie avec le mot clé static.

n Elle appartient à la classe elle-même, pas à chaque objet.
n Elle est partagé par tous les objets d’une même classe.
n Elle garde une seule et unique valeur, commune à tous les objets.

public class Point{

...
private int x ; private int y ;
Point p1 = new Point(3,8);
static int compteur = 0;
Point p2 = new Point(7,10);
public Point(int x,int y){ Point p3 = new Point(10,20);
this.x = x ; [Link]("Il y a " +
this.y = y ;
[Link] + " points");
compteur++;
}
} // l’instruction affichera : Il y a
3 points

POO en java 30
Méthode de la classe

Méthode de la classe (1)

n Une méthode de classe est une méthode qui ne nécessite pas la création d’un objet, elle
peut être appelée sans instance de la classe.
n On utilise là aussi le mot réservé static.

n Une méthode de classe ne peut accéder qu’aux attributs de la classe déclarés

comme static.

n L’appel d’une méthode de classe ne se fait pas sur un objet, mais sur une classe.

q Exemple : [Link](3.14);

POO en java 31
Méthode de la classe

Méthode de la classe (2)

n Exemple

public class MathCls {

private final static double PI = 3.14 ;
public static double getPI() {
return PI;}
public static double carre(double x) {
return x*x;}
public static double demi(double x) {
return x / 2; }
}

double i = [Link](5);
double x = [Link]();

POO en java 32
Accesseurs / Modificateurs

Méthodes accesseurs / modificateurs (1)

n L'encapsulation permet de sécuriser l'accès aux données d'une classe.

n Ainsi, les données déclarées private à l'intérieur d'une classe ne peuvent être accédées et
modifiées que par des méthodes définies dans la même classe.

n Par convention, les accesseurs commencent par get et les modificateurs commencent
par set.

POO en java 33
Accesseurs / Modificateurs

Méthodes accesseurs / modificateurs (2)

public class Point{

private int x, y ;
public Point (int x, int y){
this.x = x ;
this.y = y;}
public int getX(){ return x; } Accesseurs
public int getY(){ return y;}
Public void setX(int x){
this.x = x;
}
public void setY(int y){ Modificateurs
this.y = y;
}

POO en java 34
L’autoréférence this

L’autoréférence this(1)

Le mot-clé this représente l’objet courant sur lequel une méthode ou un constructeur est exécuté.
Parmi les cas d’utilisation de this:
1. Distinguer un attribut d’un paramètre.
2. Retourner l’objet courant.

POO en java 35
L’autoréférence this

L’autoréférence this(2)

1. Distinguer un attribut d’un paramètre.

public class Point {

private int x, y;
// Constructeur
public Point(int x, int y) {
this.x = x; // this.x: attribut de l’objet
this.y = y; // "y" → paramètre
}

POO en java 36
L’autoréférence this

L’autoréférence this(4)
2. Retourner l’objet courant

public class Point {

private int x, y;
public Point(int a, int b) {
x = a;
y = b; public class TestPoint {
} public static void main(String[] args) {
public Point afficher() { Point p = new Point(2, 3);
[Link]("(" + x + ", " + y + ")"); [Link]().deplacer().afficher();
return this; // renvoie l'objet courant }
} }
public Point deplacer() {
x++;
y++;
return this;
}
}
POO en java 37
Surcharge des fonctions

Surcharge des fonctions (1)

La surcharge (ou Overloading) consiste à définir plusieurs fonctions membres portant le même nom,
mais ayant:
Ø des listes de paramètres différentes (nombre ou type),
§ Le compilateur choisit la bonne fonction en fonction des arguments passés.
§ La surcharge n’est possible que si les fonctions se distinguent par:
-le nombre de paramètres,
-ou le type des paramètres,
-ou les deux à la fois.
Ø La valeur de retour seule ne permet pas de surcharger.

POO en java 38
Surcharge des fonctions

Surcharge des fonctions (2)

Remarque: Puisque les constructeurs sont aussi des méthodes spéciales, ils peuvent donc être surchargés
exactement comme les autres méthodes.
Le compilateur choisit automatiquement le bon constructeur selon: le nombre, le type des paramètres
passés.
public class Point { public class TestPoint {
private int x, y; public static void main(String[] args) {
public Point(int a, int b) { Point p1 = new Point(3, 5);
x = a; Point p2 = new Point(4);
y = b;} [Link]();
Exemple:
public Point(int a) { [Link]("Coordonnées du point :");
x = a; }
y = a;} }
public void afficher() {
[Link]("(" + x + ", " + y + ")");}
public void afficher(String msg) {
[Link](msg + " (" + x + ", " + y + ")");}
}
POO en java 39
 Exercice d’application

1. Créez une classe Voiture avec les attributs: marque: (String), vitesse(int) et nbVoitures: représentant le nombre
total de voitures créées.
2. Créez le constructeur par défaut qui initialise marque = "Inconnue" et vitesse = 0.
3. Créez le constructeur paramétré: initialise marque et vitesse avec les valeurs données.
Ø À chaque création d’objet, incrémentez nbVoitures.
4. Créez les méthodes d’accès et de modification: getMarque(), getVitesse(), setMarque(String), setVitesse(int).
5. Ajoutez une méthode d’affichage qui affiche la marque et la vitesse d’une voiture.
6. Ajoutez une méthode surchargée accelerer():
• Version sans paramètre → augmente la vitesse de 10 km/h,
• Version avec un paramètre entier → augmente la vitesse du nombre de km/h passé.
7. Ajoutez une méthode qui affiche le nombre total d’objets Voiture créés.
Ø Dans une classe TestVoiture, écrivez le programme principal:
1. Créez trois objets: v1, v2 et v3, en initialisant les attributs de v2 et v3.
2. Affichez les informations de chaque voiture.
3. Changez la vitesse de v1.
4. Appelez accelerer() (avec et sans paramètre) sur v2.
5. Affichez le nombre total de voitures créées.

POO en java 40
 Solution (1) // 3) Accesseurs / mutateurs
public String getMarque() { return marque; }
public int getVitesse() { return vitesse; }
public class Voiture {
public void setMarque(String marque) {
// Attributs d'instance
[Link] = marque; }
private String marque;
public void setVitesse(int vitesse) {
private int vitesse;
[Link] = vitesse; }
// 4) Affichage
// Attribut de classe (partagé)
public void afficher() {
private static int nbVoitures = 0;
[Link]("Voiture[" + marque + "] - vitesse = " +
vitesse + " km/h") }
// 1) Constructeur par défaut
// 5) Surcharge de accelerer()
public Voiture() {
public void accelerer() {
[Link] = "Inconnue";
[Link] += 10;
[Link] = 0;
}
nbVoitures++; // compter chaque objet créé}
public void accelerer(int v) {
// 2) Constructeur paramétré
[Link] += v; }
public Voiture(String marque, int vitesse) {
// 6) Méthode de classe pour afficher le total
[Link] = marque;
public static void afficherNbVoitures() {
[Link] = vitesse;
[Link]("Nombre total de voitures créées : " +
nbVoitures++; }
nbVoitures);}
POO en java 41
 Solution (2)

public class TestVoiture {

public static void main(String[] args) { // Appeler accelerer() (avec et sans paramètre) sur
// Créez trois objets (v2 et v3 initialisés avec v2
des paramètres) [Link](); // +10
Voiture v1 = new Voiture(); [Link](25); // +25
Voiture v2 = new Voiture("Peugeot", 50); [Link]();
Voiture v3 = new Voiture("Renault", 90); // Afficher le nombre total de voitures créées
// Afficher les infos de chaque voiture [Link](); // méthode
[Link](); statique appelée via la classe
[Link](); }
[Link](); }
// Changer la vitesse de v1
[Link](30);
[Link]();

POO en java 42
Héritage & Polymorphisme
Pr. AIT MAIT Hind

2025/2026
Héritage

Héritage
Créer une nouvelle classe à partir d'une classe existante en partageant les attributset ses méthodes.
Lesrelations d’héritage forment une hiérarchie
Spécialisation (classes descendantes)
Généralisation (classes ascendantes)
Au sommet se situe la classe mère
(ou superclasse)
En dessous:
la classe fille (ou sous-classe)

POO en java 1
Héritage

Avantages
Spécialisation/Enrichissement
La classe s’enrichie en ajoutant ses propresattributset méthodes.

Redéfinition
La classe fille redéfinit les méthodes d’une classe mère de façon à adapter son comportement.

Réutilisation
Evite la réécriture du code existant en factorisant les parties communes du code.

POO en java 2
Héritage

Exemple des Véhicules Vehicule

Vitesse: double
Toutes lesclasses filleshéritent Poids: double
void demarrer()
Des attributs void avancer()

Des méthodes
Chaque type à ses spécificités
Voiture Avion Bateau
Des attributssupplémentaires nbPorte: entier nbPassager: Entier moteurs: booleen

Des méthodes supplémentaires void avancer() void avancer() void avancer()

void planer() void jeterEncre()
Une réécriture du comportement de ses parents

POO en java 3
Héritage

Héritage en JAVA
Utilisation du mot clé extends

public class Vehicule {

private double vitesse;
private double poids; public class Voiture extends Vehicule{
public void demarrer(){……} private int nbPorte;
public void avancer(){……} public void avancer(){……}
} }

POO en java 4
Héritage

L'accès aux propriétés héritées

n Les variables et méthodes définies avec le modificateur d'accès public restent publiques à travers l'héritage
et toutes les autres classes.

n Une variable d'instance définie avec le modificateur private est bien héritée mais elle n'est pas accessible
directement mais via les getters et setters.

n Un membre de la classe de base déclaré protected est accessible à ses classes dérivées ainsi qu’aux classes
du même paquetage.

POO en java 5
Héritage

Héritage et constructeur

n En Java, le constructeur de la classe dérivée doit prendre en charge l’intégralité de la construction de l’objet.

n Si un constructeur d’une classe fille appelle un constructeur de la classe mère, il doit obligatoirement s’agir

de la première instruction du constructeur et ce dernier est désigné par le mot-clé super.

n Sans précision du constructeur, c'est le constructeur par défaut qui est appelé (constructeur sans arguments).

POO en java 6
Héritage

Héritage et constructeur: Aucun constructeur explicite nulle part

public class Point {

// Aucun constructeur explicite
}

public class PointGraphique extends Point {

// Aucun constructeur explicite
}

PointGraphique p = new PointGraphique();

// Appel au constructeur par défaut de PointGraphique qui
appelle le constructeur par défaut de Point

POO en java 7
Héritage

Héritage et constructeur: Aucun constructeur explicite dans la classe mère

public class Point {

protected int x,y;
// Aucun constructeur explicite
}
public class PointGraphique extends Point {
Private String couleur;
public PointGraphique(String couleur) {
[Link]=couleur;}

PointGraphique p = new PointGraphique(”green”); // Appel au

constructeur avec arguments de PointGraphique
PointGraphique p = new PointGraphique(); // Erreur vu que
PointGraphique dispose d’un constructeur (avec argument)

POO en java 8
Héritage

Héritage et constructeur: Aucun constructeur explicite dans la classe dérivée (1)

public class Point { protected int x,y;

public Point(){ …… } // constructeur sans arguments
public Point(int x, int y){ …… } // avec arguments
}

public class PointGraphique extends Point {

// Aucun constructeur explicite
}

PointGraphique p = new PointGraphique();

// Appelle le constructeur par défaut qui appelle le
constructeur sans arguments de Point

POO en java
Héritage

Héritage et constructeur: Aucun constructeur explicite dans la classe dérivée(2)

public class Point {
protected int x,y;
public Point(int x, int y){ …… } // avec arguments
}

public class PointGraphique extends Point {

// Aucun constructeur explicite.
// Erreur à la compilation!!!!
}

n Le constructeur par défaut de PointGraphique cherche un constructeur sans argument de Point.

n Puisque Point dispose d'au moins un constructeur (avec argument), il remplace le constructeur
sans argument, d'où erreur.

POO en java 10
Héritage

Héritage et constructeur: Plusieurs constructeurs dans les classes mère et fille

public class Point {

protected int x,y;
public Point(){ …… }
public Point(int x, int y){ ……}
}

public class PointGraphique extends Point {

private String couleur;
public PointGraphique() {}
public PointGraphique(int x, int y, String c) {
super(x,y);
couleur = c;
}
}

POO en java 11
Héritage

Héritage en chaîne (Dérivations successives)

n D’une même classe peuvent être dérivées plusieurs classes différentes,

n Une classe dérivée peut, à son tour, servir de classe de base pour une autre.

POO en java 12
Héritage

Héritage en chaîne

POO en java 13
Héritage

Redéfinition et surcharge des méthodes

n La redéfinition du comportement des méthodes de la classe mère peut prendre trois formes:

q Surcharge (overloading): est la capacité d'avoir plusieurs méthodes avec le même nom mais des
signatures différentes (nombre ou type de paramètres) dans la même classe ou dans une classe héritée.

q Redéfinition (overriding): est la capacité de la classe fille à fournir une nouvelle implémentation pour une
méthode héritée de la classe mère. La signature (nom et paramètres) doit être la même que la méthode de la classe
mère.

q Spécialisation ( specialization): la capacité de la classe fille à modifier ou affiner le comportement d'une

méthode de la classe mère, tout en conservant et en étendant souvent le comportement initial.

POO en java 14
Héritage

Surcharge d'une méthode héritée

public class Point {

Protected int x, y;
public void deplace(int dx, int dy) {
x += dx; y += dy;
}
}

public class PointGraphique extends Point {

public void deplace(float dx, float dy) {
x += dx; y += dy;
}
}

n La classe PointGraphique possède deux méthodes deplace, dont une héritée de Point.

POO en java 15
Héritage

Redéfinition d'une méthode héritée

public class Point {
protected int x, y;
public void deplace(int dx, int dy) {
x += dx;
y += dy;
}
}
public class PointGraphique extends Point {
@Override //Annotation Java pour indiquer la redéfinition
public void deplace(int dx, int dy) {
x += (dx + 0.1);
y += (dy + 0.1);
}
}
n La classe PointGraphique possède une seule méthode deplace(), qui redéfinit (override)
le comportement de celle héritée de Point.

POO en java 16
Héritage

Changement de droits d'accès en cas de redéfinition

n Le droit d'accès de la méthode redéfinie dans la classe dérivée ne doit pas être moins élevé que celui dans
la classe mère.
n private < protected < default < public

public class Point {

public void deplace(int dx, int dy) { ……}
public void affiche() { ……}

public class PointGraphique extends Point {

@Override
public void deplace(int dx, int dy) { …… } //OK
@Override
private void affiche() { …… } // Erreur à la
compilation!
}

POO en java 17
Héritage

Changement de droits d'accès en cas de surcharge

n Iln'y a pas de restriction sur le droit d'accès de la méthode surchargé de la classe dérivée, car il s'agit
de méthodes différentes, leurs signatures étant différentes.

public class Point {

public void deplace(int dx, int dy) { ……}
}

public class PointGraphique extends Point {

protected void deplace(float dx, float dy) { …… } // OK
}

POO en java 18
Héritage

Spécialisation d'une méthode héritée

public class Point { protected int x,y;
public void affiche() {
[Link] ("Mes coordonnees " + x + " " + y);
}
}
public class PointGraphique extends Point {
private String couleur;
@Override
public void affiche() {
[Link](); // Réutilisation de affiche() de Point
[Link] ("Ma couleur " + couleur);
}
}
n La classe PointGraphique possède une méthode affiche(), qui spécialise le comportement de celle héritée
de Point.

POO en java 19
Héritage

Interdire la redéfinition d'une méthode

n On peut interdire la redéfinition d'une méthode en utilisant le mot-clé final dans sa signature.

public class Point {

public final void deplace(int dx, int dy) { ……}
}

public class PointGraphique extends Point {

/* La déclaration suivante renvoie une erreur, car la méthde
'deplace' est 'final' dans Point */
@Override
public void deplace(int dx, int dy) { …… }
}

POO en java 20
Héritage

Interdire la dérivation d'une classe

n Pour interdire la possibilité d’étendre une classe, on utilise aussi mot-clé final dans sa déclaration.

public final class Point {

……
}

/* La déclaration suivante renvoie une erreur, car

Point ne peut pas être étendue à cause du ‘final’*/
public class PointGraphique extends Point {
……
}

POO en java 21
Exercice

§ Créez une classe «House », avec un attribut « surface », un constructeur qui définit sa valeur et une méthode «Display »
pour afficher « Je suis une maison, ma surface est de XXX m2 » (XXX: la valeur de surface). Incluez aussi des getters
et des setters pour la surface.
§ La classe «House » contiendra une porte (Door). Chaque porte aura un attribut «color » (de type String), et une
méthode « Display » qui affichera « Je suis une porte, ma couleur est bleu ». Inclure un getter et un setter. Créez
également les méthodes « GetDoor » et « SetDoor » dans la classe « House ».
§ La classe « Apartment » est une sous-classe de la classe « House », avec une surface prédéfinie de 50m².
§ Créez également une classe Person, avec un nom (de type String). Chaque personne aura une maison. La méthode
«Display » pour une personne affichera son nom, les données de sa maison et les données de la porte de cette maison.
§ Écrivez un Main pour créer un Apartment, une personne pour y vivre et pour afficher les données de la personne.

POO en java 22
Exercice: Solution (1)

class House class Door

{ {
protected int surface; protected String color;
protected Door door; public Door()
public House(int surface) {
{ color = "blue";
[Link] = surface; }
door = new Door(); public Door(String color)
} {
public int getSurface() {return surface;} [Link] = color;
public void setSurface(int value) }
{ public String getColor(){return color;}
surface = value; public void setColor(String value)
} {
public Door getDoor(){return door;} color = value;
public void setDoor(Door d) { }
door = d;} public void display()
public void display() {
{[Link]("Je suis une maison, [Link]("Je suis une porte, ma
ma surface est de "+ surface +" m2.");}} couleur est "+ color +".");}}

POO en java 23
Exercice: Solution (2)
class Apartment extends House
{ public String getName(){return name;}
public Apartment() public void setName(String value)
{super(50);} {
@override name = value;
public void display() }
{ public House getHouse()
[Link]("Je suis un {
appartement, ma surface est " + surface + return house;
" m2");}} }
class Person public void setHouse(House h)
{ {
protected String name; house = h;
protected House house; }
public Person() public void display()
{name = "Thomas"; {
house = new House(150);} [Link]("Je m'appele "+ name
public Person(String name, House house) +".");
{ [Link]();
[Link] = name; [Link]();
[Link] = house;} }}

POO en java 24
Exercice: Solution (3)

//Classe de test
public class Main
{
public static void main(String[] args)
{
Apartment MyApartament = new Apartment();
Person person = new Person();
[Link] = "Thomas";
[Link] = MyApartament;
[Link]();
}
}

POO en java 25
Surclassement

Le surclassement (upcasting) consiste à convertir un objet d’une classe fille vers une référence de la
classe mère.
class Animal {
Exemple: void crier(){[Link]("Animal");} }
class Chat extends Animal {
@Override
void crier(){[Link]("Chat");} }

Animal a = new Chat(); //UPCASTING

POO en java 26
Liaison Dynamique

Ø Liaison dynamique (Dynamic Binding): mécanisme par lequel la méthode appelée dépend du type réel
de l'objet, et non du type de la référence.
Ø Décision prise à l’exécution, pas à la compilation.
Ø C’est le processus technique par lequel Java choisit quelle méthode exécuter à l’exécution, selon le type
réel de l’objet.
Ø La liaison dynamique intervient lorsque la méthode est redéfinie dans une classe fille.

POO en java 27
Polymorphisme

A quoi servent l’upcasting et la liaison dynamique?

Ø A la mise en œuvre du polymorphisme

§ Le mot polymorphisme est apparu dans la Grèce antique, Il signifie quelque chose qui peut prendre
plusieurs formes.

§ Le polymorphisme est la capacité d’un objet à être manipulé via une référence d’un type parent tout en
exécutant son propre comportement réel.

Ø Cela est rendu possible grâce à la redéfinition de méthodes et à la liaison dynamique.

POO en java 28
Polymorphisme

§ Exemple (1)

class Animal {
public void talk() {
[Link]("Je suis un animal!");}
}

class Cat extends Animal {

@Override
public void talk() {
[Link]("Meow !");} class Dog extends Animal {
public void scratch() { @Override
[Link]("je griffe !"); public void talk() {
} [Link]("Ouaf !");}
} public void attack() {
[Link]("j'attaque !");}
}

POO en java 29
Polymorphisme

§ Exemple (2)
public class AnimalTester {
public static void main(String[] args) {
Dog monChien = new Dog();
[Link]();
[Link]();
Cat monChat = new Cat();
[Link]();
[Link]();
Animal monAnimal = new Dog(); //Instance de Dog déclarée avec référence
Animal
[Link]();
Animal monAnimal2 = new Cat(); //Instance de Cat déclarée avec
référence Animal
[Link]();
[Link](); //cause une erreur de compilation
[Link](); //cause une erreur de compilation
}}

POO en java 30
Polymorphisme

§ Exemple (3)

Ø Dans ce cas pour le compilateur considère que la méthode talk() de monChien est la méthode de la
classe Dog, puisque la référence de l'objet est Dog, aussi la JVM va exécuter la méthode de la classe
Chien puisqu'elle a été redéfinie.
Ø Dans la même logique le compilateur considère que la méthode talk() de monAnimal est la méthode
de la classe Animal, puisque la référence de l'objet est Animal, mais ici la JVM va exécuter la
méthode de la classe Chien quand même puisqu'elle a été redéfinie.

POO en java 31
Polymorphisme

§ Exemple (4)

POO en java 32
Polymorphisme

Tableaux polymorphiques

Les tableaux polymorphiques en Java sont des tableaux qui peuvent contenir des objets de
différentes classes qui héritent d'une même classe parente.

Animal[] animaux = new Animal[2];

animaux[0] = new Dog();
animaux[1] = new Cat();
for (Animal animal : animaux) {
[Link](); // appelle la méthode talk() de chaque type
d’objet, soit talk() de la classe Dog ou talk() de la classe Cat.}

POO en java 33
Sous-classement

Le sous-classement (Downcasting) consiste à convertir une référence d’une classe parente vers une référence de
la classe fille.
• Permet d’accéder aux méthodes spécifiques de la classe fille.
• Doit être utilisé avec précaution pour éviter les erreurs de type ClassCastException.
class Animal {
void crier() {[Link]("Animal"); }}
class Chat extends Animal {
@Override
void crier() {[Link]("Chat");}
Exemple: void miauler() {[Link]("Miaou"); }}
public class Main {
public static void main(String[] args) {
Animal a = new Chat(); // Upcasting
[Link](); // Affiche "Chat"
// Downcasting
if (a instanceof Chat) {
((Chat) a).miauler(); // Affiche "Miaou“
}}}

POO en java 34
Sous-classement

§ Correction: Exemple (page 30)

public class AnimalTester {
public static void main(String[] args) {
Dog monChien = new Dog();
[Link]();
[Link]();
Cat monChat = new Cat();
[Link]();
[Link]();
// Upcasting
Animal monAnimal = new Dog();
[Link](); // Appelle la méthode redéfinie dans Dog
Animal monAnimal2 = new Cat();
[Link](); // Appelle la méthode redéfinie dans Cat
// Downcasting pour accéder aux méthodes spécifiques
if (monAnimal instanceof Dog) {
((Dog) monAnimal).attack(); // Ok }
if (monAnimal2 instanceof Cat) {
((Cat) monAnimal2).scratch(); // OK}}}

POO en java 35
Masquage

Le Masquage se produit lorsqu'une classe dérivée définit une méthode statique avec la même signature
(nom et paramètres) qu'une méthode statique de sa classe de base.
• Ceci n’est pas de la redéfinition (Override). Java ne permet pas la redéfinition des méthodes
statiques.
• La méthode de la classe dérivée masque (cache) celle de la classe de base, mais ne la remplace pas.

public class Animal {

public static void run() {
[Link](“An animal runs”);
Exemple (1/3) }
}
public class Cat extends Animal{
public void run() {//Erreur de compilation (interdit de
redéfinir une méthode statique)
[Link](“A cat runs”);}}

POO en java 36
Masquage
public class Animal {
public static void run() {
[Link](“An animal runs”);}
}
Exemple (2/3) public class Cat extends Animal{
public static void run() {
[Link](); //Erreur de compilation (interdit d'appeler une
méthode statique avec super)
[Link](); //Ok
[Link](“A cat runs”);}}

public class AnimalTester {

public static void main(String[] args){
Animal monAnimal = new Animal();
Exemple (3/3) Animal monChat = new Cat();
[Link](); //An animal runs On peut appeler la méthode cachée en
[Link](); //An animal runs convertissant l’objet monChat en un Cat
((Cat) monChat).run(); //A cat runs ou en appelant la méthode directement par
[Link](); //A cat runs
le nom de la classe.
}}

POO en java 37
Exercice

Ecrire les classes nécessaires au fonctionnement du programme suivant (en ne fournissant que les méthodes nécessaires à
ce fonctionnement).

public class TestMetiers {

public static void main(String[] argv) {
Personne[] personnes = new Personne[3];
personnes[0] = new Menuisier("Paul");
personnes[1] = new Plombier("Jean");
personnes[2] = new Menuisier("Adrien");
for (int i = 0; i < [Link]; i++)
personnes[i].affiche();
}
}

POO en java 38
Solution

//Classe fille Menuisier

class Menuisier extends Personne {
public Menuisier(String nom) {
super(nom);
//Classe mère }
class Personne { @Override
protected String nom; public void affiche() {
[Link]("Je suis un
public Personne(String nom) { menuisier : " + nom);
[Link] = nom; }
} }
public void affiche() { //Classe fille Plombier
[Link]("Je suis une class Plombier extends Personne {
personne : " + nom); public Plombier(String nom) {
} super(nom);
} }
@Override
public void affiche() {
[Link]("Je suis un
plombier : " + nom);}}

POO en java 39
Classe abstraite & Interface
Pr. AIT MAIT Hind

2025/2026
Introduction

Exemple introductif (1)

qUn grand classique: les formes géométriques
qOn veut définir une application permettant de manipuler des formes géométriques (triangles, rectangles,
cercles,…).
qChaque forme est définie par sa position sur l’écran.
qChaque forme peut être déplacée (modification de position), calculer son périmètre, sa surface, etc.
largeur
r v2

hauteur
x,y
x,y
x,y v1

POO en java 1
Introduction

Exemple introductif (2)

largeur
class Forme { r

hauteur
v2
protected double x,y;
public void deplacer(double dx, x,y
double dy) { x,y x,y
v1
x += dx ; y += dy; Forme
}
} double x,y;//centre du cercle

deplacer(double dx,double dy)

class Cercle extends Forme {
protected double r;
public double surface(){
return [Link] * r * r;
} Cercle Rectangle Triangle
protected double périmetre() { double largeur ; double x1,y1 ;
double r double x2,y2 ;
return 2 * [Link] * r; } double hauteur ;
}
double surface() double surface() double surface()
double périmetre() double périmetre() double périmetre()

POO en java 2
Introduction
Exemple introductif (3)
§ Un besoin: profiter du polymorphisme

public class ListeDeFormes {

private Forme[] tabForme = new Forme[10];
private int nbFormes = 0;
public void ajouter(Forme f) {
tabForme[nbFormes++] = f ;
}
public void toutDeplacer(double dx,double dy) {
for (int i=0; i < nbFormes; i++)
tabFrome[i].deplace(dx,dy);
}
. . . . . .

Polymorphisme: Prise en compte de nouveaux types de forme

sans modification du code.

POO en java 3
Introduction

Exemples introductifs (4)

n Problème

. . .
public double perimetreTotal() { double pt = 0.0;
for (int i=0; i < NbFormes; i++)
pt += tabForme[i].perimetre(); // ERREUR
return pt;
}

La méthode perimetre() n’est pas définie dans la classe Forme (type déclaré) : appel non valide!!

POO en java 4
Introduction

Exemple introductif (4)

n Solution ?
q Définir une méthode perimetre() dans Forme ?

public double perimetre(){ return 0.0; // ?? }

q Les classes abstraites sont une solution propre et élégante.

n Servent à définir des concepts incomplets qui devront être implémentés dans les sous-classes.

public abstract class Forme { // Classe abstraite

protected double x,y;
public void deplacer(double dx, double dy) {
x += dx; y += dy;
}
// Méthodes abstraites
public abstract double perimetre();
public abstract double surface() ;
}

POO en java 5
Classe abstraite

n Une classe abstraite est une classe qui ne permet pas d’instancier des objets.
n Elle ne peut servir que de classe de base pour une dérivation.
n Elle se déclare à l'aide du mot-clé abstract:

// Déclaration d'une classe abstraite

public abstract class NomDeLaClasse {
...
}

POO en java 6
Classe abstraite

Dérivation et instanciation d’une classe abstraite

public abstract class A{

public void f() { ..... } // f est définie dans A public
public abstract void g(int n); // méthode abstraite
}
public class B extends A{
@Override
public void g(int n) { ..... } // ici, on définit g
.....
}

A a ; // OK : a n’est qu’une référence sur un

objet de type A
a = new A(...) ; // ERREUR: pas d’instanciation d’objets
d’une classe abstraite
A a = new B(...) ; // OK
B b = new B(...) ; // OK

POO en java 7
Classe abstraite

Règles pour la définition des classes abstraites

n Dès lors qu'une classe contient au moins une méthode abstraite, elle est abstraite.

n Une classe abstraite ne peut être instanciée, car elle contient au moins une méthode qui n'a pas
d'implémentation.

n Une méthode abstraite doit être publique, car elle est destinée à être redéfinie dans une classe dérivée.

n Une classe dérivée d'une classe abstraite doit implémenter toutes les méthodes abstraites de sa classe mère, ou
sinon elle reste abstraite.

n Il suffit donc que la classe dérivée ne redéfinisse aucune ou une des méthodes abstraites de sa classe mère
pour rester elle-même abstraite.

POO en java 8
Classe abstraite

Exemple (1/4)

POO en java 9
Classe abstraite

Exemple (2/4)

POO en java 10
Classe abstraite

Exemple (3/4)

POO en java 11
Classe abstraite

Exemple (4/4)

POO en java 12
Classe abstraite

Exercice (1/2)
Une plateforme souhaite automatiser la validation de différents types de contenus avant publication: des articles, des
images et des vidéos.
Tous les contenus partagent des informations générales, mais la manière de valider chaque contenu est différente.
La validation peut consister à vérifier la longueur d’un texte, la résolution d’une image ou la durée d’une vidéo.
1. Créer une classe abstraite Contient:
• Attributs protégés communs : titre, auteur, dateCreation,
• un constructeur paramétré,
• une méthode: afficherInfos(),
• une méthode abstraite: valider()-> Retourne un bolean, elle représente la logique de validation, différente selon le
type de contenu.
2. Créer trois classes qui héritent de Contenu:
2.1. Article
Attributs privés: String texte; int longueurMin;
Redéfinir valider()→ retourne true si la longueur du texte ≥ longueurMin.
2.2. Image
Attributs: int largeur; int hauteur; int resolutionMin; (par ex : 800px)
Redéfinir valider()→ retourne true si la largeur et la hauteur sont ≥ resolutionMin.

POO en java 13
Classe abstraite

Exercice (2/2)

2.3. Video
Attributs: int dureeSecondes; int dureeMax; (ex : 300s)
Redéfinir valider()→ retourne true si la durée ≤ dureeMax.
3. Classe de test PlateformeValidationTest
Dans main:
1. Créer un tableau c de type Contenu.
2. Ajouter: un Article ,une Image, et une Vidéo.
3. Parcourir le tableau et appeler afficherInfos() et valider().
4. Comment assurer à l’avenir que tous les nouveaux contenus implémentent une validation personnalisée?

POO en java 14
Classe abstraite
Solution

// Classe abstraite de base

public abstract class Contenu {
protected String titre;
protected String auteur;
protected String dateCreation;

public Contenu(String titre, String auteur, String dateCreation) {

[Link] = titre;
[Link] = auteur;
[Link] = dateCreation;
}
public void afficherInfos() {
[Link]("Titre:" + titre);
[Link]("Auteur: " + auteur);
[Link]("Date création:" + dateCreation);
}
public abstract boolean valider();
}

POO en java 15
Classe abstraite
Solution (1/4)
public class Article extends Contenu {
private String texte;
private int longueurMin;
public Article(String titre, String auteur, String dateCreation, String texte, int
longueurMin) {
super(titre, auteur, dateCreation);
[Link] = texte;
[Link] = longueurMin;}
@Override
public boolean valider() {
if (texte != null) {
if ([Link]() >= longueurMin) {
return true;
}}
return false; }
@Override
public void afficherInfos() {
[Link]();
[Link]("Type:Article");
[Link]("Longueur min:" + longueurMin);
if (texte != null) { longueurTxt = [Link]();}
[Link]("Longueur txt : " + longueurTxt);}}

POO en java 16
Classe abstraite
Solution (2/4)
public class Image extends Contenu {
private int largeur;
private int hauteur;
private int resolutionMin;
public Image(String titre, String auteur, String dateCreation,int largeur, int
hauteur, int resolutionMin) {
super(titre, auteur, dateCreation);
[Link] = largeur;
[Link] = hauteur;
[Link] = resolutionMin;
}
@Override
public boolean valider() {
if (largeur >= resolutionMin && hauteur >= resolutionMin) {
return true;}
return false;}
@Override
public void afficherInfos(){
[Link]();
[Link]("Type: Image");
[Link]("Largeur:" + largeur);
[Link]("Hauteur:" + hauteur);
[Link]("Résolution min:" + resolutionMin);}}

POO en java 17
Classe abstraite
Solution (3/4)
public class Video extends Contenu {
private int dureeSecondes;
private int dureeMax;
public Video(String titre, String auteur, String dateCreation, int dureeSecondes, int
dureeMax) {
super(titre, auteur, dateCreation);
[Link] = dureeSecondes;
[Link] = dureeMax; }
@Override
public boolean valider() {
if (dureeSecondes <= dureeMax) {
return true;
}
return false;
}
@Override
public void afficherInfos() {
[Link]();
[Link]("Type: Vidéo");
[Link]("Durée: " + dureeSecondes + "s");
[Link]("Durée max: " + dureeMax + "s");
}
}

POO en java 18
Classe abstraite
Solution (4/4)

public class PlateformeValidationTest {

public static void main(String[] args) {

Contenu[] c = new Contenu[3];

c[0] = new Article("Introduction à la POO“, "Hind Ait Mait", "2025-11-27","Ceci

est un article sur la POO...“,30);

c[1] = new Image("Logo Java","Equipe Design","2025-11-20",1024, 600, 800);

c[2] = new Video("Cours POO - Partie 1","Pr. Hind","2025-11-25",250,300);

for (int i = 0; i < [Link]; i++) {

c[i].afficherInfos();
[Link]("Valide ? " + c[i].valider());
}
}
}

POO en java 19
Interface

n Une interface est une « classe » purement abstraite dont toutes les méthodes sont abstraites et publiques.
q Une façon de décrire ce que les classes doivent faire, sans préciser comment elles doivent le faire.

n Une interface ne peut contenir que

q des méthodes abstract et public

q des définitions de constantes publiques (« public static final »)

n Une interface peut avoir la même accessibilité que les classes:

q public: utilisable de partout

q sinon : utilisable seulement dans le même package

POO en java 20
Interface

Définition d’une interface

n Ladéfinition d’une interface se présente comme celle d’une classe. On y utilise le mot-clé interface à la
place de classe:

public interface I {
static final int MAXI = 100 ;
public abstract void f(int n);
public abstract void g() ;
}

Il n’est pas nécessaire de mentionner les mots-clés public et abstract ils sont facultatifs.

POO en java 21
Interface

Implémentation d’une interface

n Lorsqu’on définit une classe, on peut préciser implémente une interface donnée en utilisant le
implements, comme dans:

public class A implements I {

// A doit définir les méthodes f et g prévues dans
l’interface I
}

n2 seuls cas possibles:

q soit la classe A implémente toutes les méthodes de I.

q soit la classe A doit être déclarée abstract ; Les méthodes manquantes seront implémentées par les
classes filles de A.

POO en java 22
Interface

Implémentation d’une interface

n Une même classe peut implémenter plusieurs interfaces:

public interface I1{ void f() ;}

public interface I2{ int h() ;}

public class A implements I1, I2{

// A doit obligatoirement définir les méthodes f et h
prévues dans I1 et I2 }

POO en java 23
Interface

Variables de type interface

n Une interface peut seulement servir à déclarer une variable, un paramètre, une valeur retour, un type
de base de tableau, …
public interface I { .....}
.....
I i ; /* i est une référence à un objet d’une
classe implémentant l’interface I */

n En revanche, on pourra affecter à i n’importe quelle référence à un objet d’une classe implémentant
l’interface I.

class A implements I { ..... }

.....

I i = new A(...) ; // OK
Interface

Interface et classe dérivée

n Laclause implements est totalement indépendante de l’héritage.

n Une classe dérivée peut implémenter une interface (ou plusieurs):

public interface I {
void f(int n) ;
void g() ;
}
public class A {
.....
}

public class B extends A implements I {

/* les méthodes f et g doivent soit être déja
définies dans A, soit définies dans B */
}

25
Interface

Dérivation d’une interface

n On peut définir une interface comme
une généralisation d’une autre. public interface I1{
static final int MAXI = 100 ;
n On utilise là encore le mot-clé extends,
ce qui conduit à parler d’héritage void f(int n) ;
ou de dérivation. }

public interface I2 extends I1{

static final int MINI = 20 ;
void g() ;
}

public interface I2 { La définition de I2 est

static final int MAXI = 100 ; équivalente à
static final int MINI = 20 ;
void f(int n) ;
void g() ;
}
Interface

Exemple complet (1/3)

n On veut définir:
q Une interface nommée Affichable, dotée d’une seule méthode affiche.
q Deux classes Entier et Flottant implémentent cette interface (aucun lien d’héritage n’apparaît ici).
n Chaque classe est dotée d’un attribut valeur.
n La méthode affiche() affiche un message de l’ordre: "Je suis un flottant/entier de valeur xy").
q La méthode main utilise un tableau hétérogène d’objets de type Affichable qu’elle remplit en instanciant des objets
de type Entier et Flottant puis les affiche.
Interface

Exemple complet (2/3)

28
Interface

Exemple complet (3/3)

29
Interface
Exercice
On souhaite modéliser des objets capables de se connecter à un réseau.
Ces objets peuvent être très différents (ordinateur, imprimante, caméra…), mais ils doivent tous fournir les mêmes
opérations de connexion.
1. Créer une interface contenant deux méthodes: Connecter() et deconnecter().
2. Créer les classes suivantes qui implémentent Connectable :
a) Classe Ordinateur
Attribut privé: String nom;
Implémentations: connecter() → simule la connexion au réseau (par message d’affichage).
deconnecter() → simule la déconnexion( par message d’affichage).
b) Classe Imprimante
Attribut privé: String modele;
Implémentations: connecter() et deconnecter().
c) Classe CameraSurveillance
Attribut privé : String emplacement;
Implémentations: connecter() et deconnecter().
3. Classe de test RéseauTest
Dans la méthode main:
a) Créer un tableau de type Connectable.
b) Ajouter: un ordinateur, une imprimante ,et une caméra.
c) Parcourir le tableau et appeler: connecter() et deconnecter().

POO en java 30
Interface
Solution (1/4)

public interface Connectable {

void connecter();
void deconnecter();
}
public class Ordinateur implements Connectable {
private String nom;
public Ordinateur(String nom) {
[Link] = nom;
}
@Override
public void connecter() {
[Link]("L'ordinateur " + nom + " est connecté au réseau.");
}
@Override
public void deconnecter() {
[Link]("L'ordinateur " + nom + " est déconnecté du réseau.");
}
}

POO en java 31
Interface
Solution (2/4)

public class Imprimante implements Connectable {

private String modele;
public Imprimante(String modele) {
[Link] = modele;
}

@Override
public void connecter() {
[Link]("L’imprimante " + modele + " est connectée au réseau.");
}

@Override
public void deconnecter() {
[Link]("L’imprimante " + modele + " est déconnectée du réseau.");
}
}

POO en java 32
Interface
Solution(3/4)

public class CameraSurveillance implements Connectable {

private String emplacement;

public CameraSurveillance(String emplacement) {

[Link] = emplacement;
}

@Override
public void connecter() {
[Link]("La caméra située à " + emplacement + " est connectée au réseau.");
}

@Override
public void deconnecter() {
[Link]("La caméra située à " + emplacement + " est déconnectée du réseau.");
}
}

POO en java 33
Interface
Solution(4/4)
public class RéseauTest {
public static void main(String[] args) {

// a) Créer un tableau de type Connectable

Connectable[] tab = new Connectable[3];

// b) Ajouter : un ordinateur, une imprimante, une caméra

tab[0] = new Ordinateur("Dell Inspiron");
tab[1] = new Imprimante("HP LaserJet");
tab[2] = new CameraSurveillance("Entrée principale");

// c) Parcourir le tableau et appeler connecter() et deconnecter()

for (Connectable c : tab) {
[Link]();
[Link]();
}
}
}

POO en java 34
À réfléchir!

1. Une classe qui implémente une interface doit-elle toujours redéfinir toutes ses méthodes ?
2. Une interface peut-elle exister sans aucune classe qui l’implémente ?
3. Une classe qui hérite d’une classe abstraite est-elle obligatoirement abstraite ?
4. Pourquoi une interface ne possède pas de constructeur ?
5. Peut-on déclarer une variable de type interface même si aucune classe ne l’implémente encore ?

POO en java 35
Les collections
Pr. AIT MAIT Hind

2025/2026
Introduction

Problématique

Question: On souhaite créer un objet qui va gérer un ensemble d’éléments ou d’objets de même type.
Comment procéder ?

Exemple:
Un objet qui va gérer un ensemble d’objets de type classe Point.

POO en java 1
Introduction

Solution: Les tableaux

q Un tableau est le type d'objet le plus simple à programmer pour gérer un ensemble d'éléments
(d’objets) de même type.
q Exemple:

POO en java 2
Introduction

Synthèse sur les tableaux

q Avantages
Ø Accès par index (accès direct et rapide).
Ø Recherche efficace.

q Inconvénients
Ø Insertions et suppressions peu efficaces.
Ø Espace mémoire contigu.
Ø Nombre d’éléments borné qui doit être défini à l’avance.
Ø Les tableaux sont inadéquats pour gérer une quantité importante d'informations du même type quand leur
nombre n'est pas connu à l'avance.

=> Chercher une solution adéquate pour résoudre les limitations inhérentes aux tableaux.

POO en java 3
Introduction

Solution alternative: Les collections

q Une collection est un objet qui regroupe de multiples éléments de même type dans une seule entité.

q Regroupement mémoire non contigu d'éléments de même type.

q Utilisation de collections pour stocker, retrouver et manipuler des données.

q Le JDK fournit plusieurs types et variantes de collections sous forme de classes et interfaces pour le but de:

n adapter la structure collective aux besoins de la collection

n ne pas reprogrammer les traitements répétitifs classiques (affichage, saisie, recherche d’éléments, …)

q Ces classes et interfaces sont dans le paquetage [Link]

POO en java 4
Introduction

Structure de données

n En Java, il existe 3 sortes de structures de données

q Les tableaux
n Structure de taille fixe, accès direct aux éléments

q Les Collections
n Structure modifiable, différents algorithmes de stockage

q Les Map
n Structure modifiable, stocke des couples clé -> valeur

POO en java 5
Hiérarchie des Collections dans Java

POO en java 6
Hiérarchie des Maps dans Java

POO en java 7
Interface Iterable

q L'interface Iterable est l'interface racine pour toutes les classes de collection.
q L'interface Collection étend l'interface Iterable et, par conséquent, toutes les sous-classes de
l'interface Collection implémentent également l'interface Iterable.
q Il ne contient qu'une seule méthode abstraite qui renvoie l’objet Iterator sur les éléments de
type E.

POO en java 8
Interface Iterator (1)

n En Java toute collection possède une méthode Iterator<E> iterator() qui retourne un itérateur permettant
d'accéder aux éléments un par un dans la collection. Initialement, l'itérateur est placé « avant » le premier
élément. A chaque accès, le prochain élément est retourné et l'itérateur avance à l'élément suivant. Lors du
parcours complet d'une collection, chaque élément est retourné une seule fois, dans un ordre dépendant en
fait du type de la collection.
n Le schéma d'utilisation est toujours le même, quelle que soit la collection:
Collection<E> coll = new ...; // Collection existante, de type quelconque
// Elle contient des éléments de type E
Iterator<E> it = [Link](); // Crée un nouvel itérateur sur la
collection, // initialisé AVANT le 1er élément
while ([Link]()) { // Tant qu'il reste des éléments
E e = [Link](); // Récupère le prochain élément et avance
... // Traiter e ici
}

POO en java 9
Interface Iterator (2)

n Les collections, peuvent aussi être parcourues à l'aide du mécanisme de for each:

for (E e: coll) { // Pour tout élément e de coll ... //

Traiter e ici }

n Par rapport au parcours avec un itérateur, un for each traite systématiquement tous les éléments de la
collection. L'itérateur permet aussi d'enlever un élément pendant le parcours (Iterator possède une
méthode remove(), optionnelle, qui retire de la collection le dernier élément retourné par next().

POO en java 10
Interface Iterator (3)

n Cette interface définit des méthodes pour des objets capables de parcourir les données d'une
collection.

Méthode Rôle
boolean hasNext() indique s'il reste au moins à parcourir dans la collection
Object next() renvoie le prochain élément dans la collection
void remove() supprime le dernier élément parcouru

Collection collection = ...;

n Exemple:
Iterator iterator = [Link]();
while ([Link]()) {
[Link]("objet ="+[Link]());
}

POO en java 11
Interface Iterator (4)

n La méthode remove() permet de supprimer l'élément renvoyé par le dernier appel à la méthode next().
Il est ainsi impossible d'appeler la méthode remove() sans un appel correspondant à next().

Iterator iterator = [Link]();

if ([Link]()) {
[Link]();
[Link]();
}

n Si aucun appel à la méthode next() ne correspond à celui de la méthode remove(), une exception de
type IllegalStateException est levée.

POO en java 12
Interface List

q L'interface List est l'interface enfant de l'interface Collection.

q Il défend une structure de données de type liste dans laquelle nous pouvons stocker la
collection d'objets commandée.
q Il peut avoir des valeurs en double.
q L'interface List est implémentée par les classes: ArrayList, LinkedList, Vector
et Stack.
q Pour instancier l'interface List, il faut utiliser:
Ø List <data-type> list1= new ArrayList();
Ø List <data-type> list2 = new LinkedList();
Ø List <data-type> list3 = new Vector();
Ø List <data-type> list4 = new Stack();

q Il existe diverses méthodes dans l'interface List qui peuvent être utilisées pour
insérer, supprimer et accéder aux éléments de la liste.

POO en java 13
Interface List

§ Classe ArrayList

n Cette classe représente un tableau d'objets dont la taille est dynamique. Elle implémente l'interface
List.
n Contrairement aux LinkedList, les ArrayList sont rapides en lecture, même avec un gros volume d'objets.
n Elles sont cependant plus lentes si vous devez ajouter ou supprimer des données en milieu ou au début de
liste.
Si vous effectuez beaucoup de lectures sans vous soucier de l'ordre des éléments, optez pour une
ArrayList ;
Si vous insérez beaucoup de données au milieu de la liste, optez pour une Linkedlist.
n Les classes ArrayList et Vector sont presque identique sauf que les ArrayList ne sont pas synchronisées.

POO en java 14
Interface List

§ Classe ArrayList

import [Link];
public class TestArrayList {
public static void main(String[] args) {

ArrayList<String> list = new ArrayList<>();

[Link]("Ali");
[Link]("Sara");
[Link]("Nadia");

[Link](list); // [Ali, Sara, Nadia]

[Link](1); // supprime "Sara"

[Link](list); // [Ali, Nadia]

[Link](1, "Samira"); // insertion au milieu

[Link](list); // [Ali, Samira, Nadia]
}
}
POO en java 15
Interface List

§ Classe LinkedList

q Il existe une autre structure de données très répandue, la liste chaînée, qui permet de résoudre les problèmes
des tableaux dynamiques (ArrayList).
q une liste chaînée stocke chaque objet avec un lien qui y fait référence. Chaque lien possède également
une référence vers le lien suivant de la liste.
q Avec Java, chaque élément d'une liste chaînée possède en fait deux liens, c'est-à-dire que chaque élément est
aussi relié à l'élément précédent.

POO en java 16
Interface List

§ Classe LinkedList

import [Link];
public class ExempleLinkedList {
public static void main(String[] args) {
LinkedList<String> liste = new LinkedList<>();

[Link]("Ali");
[Link]("Sara");
[Link]("Nadia");
// Suppression d’un élément
[Link](1); [Link]("Après
suppression : " + liste); // [Ali, Nadia]

for (String nom : liste) {

[Link](nom);//Ali
//Nadia
} }}

POO en java 17
Interface List

§ Classe Vector
q Vector est une ancienne implémentation de l’interface List,
basée sur un tableau dynamique, comme ArrayList.
q La particularité principale de Vector est que toutes ses
méthodes sont synchronisées, ce qui le rend thread-safe:
plusieurs threads peuvent l’utiliser simultanément sans
corrompre les données.
q Aujourd’hui, Vector est considéré comme une classe
héritée (legacy).
q Dans les applications modernes, on préfère utiliser
ArrayList ou, en cas de multithreading, des classes
spécialisées comme CopyOnWriteArrayList.

POO en java 18
Interface List

§ Classe Vector

import [Link];
import [Link];
public class ExempleVector {
public static void main(String[] args) {
Vector<String> vect = new Vector<>();
// Ajout d’éléments
[Link]("Ali");
[Link]("Sara");
[Link]("Nadia");
[Link]("Contenu du Vector : " + vect);

[Link]("Élément à l’index 1 : " + [Link](1));

[Link](2);
[Link]("Après suppression : " + vect);

Iterator<String> it = [Link]();
while ([Link]()) {
[Link]([Link]());
}}}

POO en java 19
Interface List

§ Classe Stack

q La classe Stack est une structure de données basée sur le principe LIFO (Last In, First Out).
q Stack hérite de la classe Vector, et utilise donc un tableau dynamique synchronisé. Cela signifie que
toutes ses méthodes sont thread-safe, mais potentiellement plus lentes.
q Aujourd’hui, la classe Stack est considérée comme obsolète (legacy). Dans les applications modernes,
Java recommande d'utiliser Deque (comme ArrayDeque) pour implémenter une pile.

POO en java 20
Interface List

§ Classe Stack

import [Link];

public class ExempleStack {

public static void main(String[] args) {
Stack<String> stack = new Stack<>();

[Link]("Ali"); // empiler
[Link]("Sara");
[Link]("Nadia");

[Link](stack); // [Ali, Sara, Nadia]

[Link]([Link]()); // Nadia
[Link]([Link]()); // Nadia (retiré)
[Link](stack); // [Ali, Sara]
}
}

POO en java 21
Interface Queue, Deque

• L’interface Queue<E> modélise une file d’attente. Dans la plupart des implémentations, elle suit le principe
FIFO (First In, First Out). Elle définit notamment les méthodes add(E e), qui ajoute un élément en fin de file, et
remove(), qui retire et retourne l’élément en tête de la file.

• L'interface Deque<E> (Double Ended Queue) spécialise une Queue<E> avec des méthodes d'insertion, d'accès
et de retrait en tête et queue de liste: addFirst, addLast, removeFirst, removeLast, getFirst, getLast. Ces
méthodes permettent notamment d'utiliser Deque comme une pile (LIFO, Last In First Out), en considérant la
tête comme le sommet de la pile.

POO en java 22
Interface Queue

§ Classe PriorityQueue
La classe PriorityQueue est une file qui ne respecte pas l’ordre d’arrivée des éléments, mais leur priorité.
Lorsque vous ajoutez des éléments, ils peuvent être insérés dans n’importe quel ordre, mais la file récupère
toujours en premier l’élément qui a la plus haute priorité (selon un ordre défini par Java pour les types simples
comme les nombres).

PriorityQueue<Integer> pq = new PriorityQueue<>();

[Link](30);
[Link](5);
[Link](20);

[Link]([Link]()); // Affiche 5 (le plus petit)

[Link]([Link]()); // Affiche 20
[Link]([Link]()); // Affiche 30

POO en java 23
Interface Deque

q Une Deque (Double-Ended Queue) est une file à deux extrémités.

q Elle permet d’ajouter et de retirer des éléments au début ou à la fin.

q L’interface Queue peut être instanciée comme suit:

• Queue< data-type > q1 = new LinkedList ();
• Queue< data-type > q2 = new ArrayDeque ();

POO en java 24
Interface Deque
§ Version 1 : LinkedList utilisée comme une file (FIFO)

public class Test {

public static void main(String[] args) {
// LinkedList utilisée comme une FILE via Deque
Deque<String> ville = new LinkedList<>();
[Link]("Casablanca");
[Link]("Marrakech");
[Link]("Agadir");
[Link]("Tanger"); Agadir
[Link](); // enlève "Casablanca" Tanger
[Link](); // enlève "Marrakech"
Iterator<String> it = [Link]();
while ([Link]()) {
[Link]([Link]());
}
}
}

POO en java 25
Interface Deque
§ Version 2 : LinkedList utilisée comme une pile (LIFO)

public class Test {

public static void main(String[] args) {
// LinkedList utilisée comme une PILE via Deque
Deque<String> ville = new LinkedList<>();
// Empiler (ajout en tête)
[Link]("Casablanca");
[Link]("Marrakech");
[Link]("Agadir");
[Link]("Tanger");
// Dépiler Marrakech
[Link](); // enlève "Tanger" Casablanca
[Link](); // enlève "Agadir"
// Parcours
for (String v : ville) {
[Link](v);
}
}
}

POO en java 26
Interface Queue

§ Classe ArrayDeque

q Une ArrayDeque est une structure performante qui peut se comporter comme une file ou comme une pile selon
les méthodes utilisées.

q Contrairement à LinkedList, elle n’implémente pas List.

public class TestQueue {

public static void main(String[] args) {
Deque<String> d = new ArrayDeque<>();
// Ajout en fin (file)
[Link]("A");
[Link]("B");
[Link]("C");

// Retrait au début
[Link]([Link]()); // A
[Link]([Link]()); // B
}}

POO en java 27
Interface Set

n Un ensemble (Set) est une collection qui n'autorise pas l'insertion de doublons.
n Trois classes implémentent l'interface Set: HashSet, LinkedHashSet et TreeSet.
à les éléments d'un objet HashSet ne sont pas triés et l’ordre d’insertion n’est pas garanti.
à les éléments d'un objet LinkedHashSet ne sont pas triés et l’ordre d’insertion est garanti.
à les éléments d'un objet TreeSet sont tries.

POO en java 28
Interface Set
§ Classe HashSet

public class TestHashSet {

public static void main(String[] args) { [Marrakech,Tanger,Agadir]
// Création d'un HashSet Marrakech
Set<String> hs = new HashSet<>(); Tanger
Agadir
// Ajout des éléments
[Link]("Agadir");
[Link]("Marrakech"); [Tanger,Marrakech,Agadir]
[Link]("Tanger");
Tanger
[Link]("Agadir");
Marrakech
Agadir
// Affichage direct
[Link]("Parcours avec affichage direct:");
[Link](hs);
[Agadir,Tanger,Marrakech]
// Parcours avec Iterator
Agadir
[Link]("\nParcours avec Iterator :");
Iterator<String> it = [Link](); Tanger
while ([Link]()) { Marrakech
[Link]([Link]());
}}}

POO en java 29
Interface Set
§ Classe LinkedHashSet

public class TestLinkedHashSet {

public static void main(String[] args) {

// Création d'un LinkedHashSet

Set<String> villes = new LinkedHashSet<>();

// Ajout des éléments

[Link]("Agadir"); [Agadir,Marrakech,Tanger]
[Link]("Marrakech");
[Link]("Tanger");
[Link]("Agadir");
// Affichage
[Link](villes);
}
}

POO en java 30
Interface Set

§ Classe TreeSet

n Cette classe représente un ensemble trié d'éléments.

n Cette classe permet d'insérer des éléments dans n'importe quel ordre et de restituer ces éléments dans un
ordre précis lors de son parcours.

n L'ordre utilisé est celui indiqué par les objets insérés si ils implémentent l'interface Comparable pour
un ordre de tri naturel ou fournir un objet de type Comparator au constructeur de l'objet TreeSet pour
définir l'ordre de tri.

POO en java 31
Interface Set

§ Classe TreeSet

public class TestTreeSet {

public static void main(String args[]) {

Set<String> ts = new TreeSet<>();

[Link]("BBBBB");
AAAAA
[Link]("CCCCC");
BBBBB
[Link]("DDDDD");
CCCCC
[Link]("BBBBB"); DDDDD
[Link]("AAAAA");

Iterator<String> iterator = [Link]();

while ([Link]()) {
[Link]([Link]());
}
}
}

POO en java 32
Interface Map

n Ce type de collection gère les éléments avec deux entités: une clé et une valeur associée.

n Les principales classes qui l’implémentent sont: HashMap, TreeMap, LinkedHashMap…

n La clé doit être unique donc il ne peut y avoir de doublons.

n En revanche la même valeur peut être associée à plusieurs clés différentes.

n L’interface Map n’hérite pas de Iterable. On ne peut pas parcourir directement une Map avec un itérateur classique.

n Le parcours se fait via des méthodes fournies par Map :

• keySet() → parcours des clés
• values() → parcours des valeurs
• entrySet() → parcours des paires clé / valeur

POO en java 33
Interface Map
§ Classe HashMap
public class TestHashMap {
public static void main(String[] args) {
Map<String, Integer> notes = new HashMap<>();
// Insertion des éléments
[Link]("Ali", 14);
n Aucun ordre garanti [Link]("Sara", 16);
[Link]("Yassine", 12);
lors du parcours des éléments. [Link]("Ali", 15);
// Recherche par clé
[Link]("Note de Sara : " +
[Link]("Sara"));

// Suppression d'un élément

Note de Sara : 16
[Link]("Yassine");
Parcours de la HashMap:
Sara : 16 // Parcours de la HashMap
Ali : 15 [Link]("\nParcours de la HashMap:");
Note de Sara : 16 for ([Link]<String, Integer> entry:
Ou bien Parcours de la HashMap: [Link]()) {
[Link]([Link]() + " : " +
Ali : 15 [Link]());
Sara : 16 }}}

POO en java 34
Interface Map
§ Classe LinkedHashMap public class TestLinkedHashMap {
public static void main(String[] args) {

n LinkedHashMap est une classe qui hérite de HashMap. // Création d'une LinkedHashMap
Map<String, Integer> notes = new
n Conserve l’ordre d’insertion des clés lors du parcours. LinkedHashMap<>();

// Insertion des éléments

[Link]("Ali", 14);
[Link]("Sara", 16);
[Link]("Yassine", 12);
[Link]("Omar", 15);
Ali : 14
// Parcours : ordre d'insertion
Sara : 16
conservé
Yassine : 12 for ([Link]<String, Integer> entry
Omar : 15 : [Link]()) {
[Link]([Link]()
+ " : " + [Link]());
}
}
}

POO en java 35
Interface SortedMap

n Cette interface définit une collection de type Map triée sur la clé. Elle hérite de l'interface Map.
n Le tri peut être assuré par deux façons:
q les clés contenues dans la collection implémentent l'interface Comparable pour définir leur ordre
naturel.
q il faut fournir au constructeur de la collection un objet Comparator qui définit l'ordre de tri à
utiliser.

POO en java 36
Interface Comparable

n L'interface Comparable représente un ordre naturel.

n Tous les objets qui doivent définir un ordre naturel utilisé par le tri d'une collection doivent implémenter
cette interface.

n Cette interface ne définit qu'une seule méthode: int compareTo(Object)

n Cette méthode doit renvoyer une:
q valeur entière négative si l'objet courant est inférieur à l'objet fourni.
q valeur entière positive si l'objet courant est supérieur à l'objet fourni.
q valeur nulle si l'objet courant est égal à l'objet fourni.

POO en java 37
Interface Comparable
§ Exemple avec Classe TreeMap

import [Link];
import [Link];
public class TestTreeMap {
public static void main(String[] args) {
Map<String, Integer> notes = new TreeMap<>();

// Insertion (ordre quelconque)

[Link]("Sara", 16);
[Link]("Ali", 14); Ali : 14
[Link]("Omar", 15); Omar : 15
[Link]("Yassine", 12); Sara : 16
Yassine : 12
// Parcours
for ([Link]<String, Integer> entry: [Link]())
{
[Link]([Link]() + " : " +
[Link]());
}}}

POO en java 38
Interface Comparator

n Cette interface représente un ordre de tri quelconque. Elle est utile pour permettre le tri d'objet qui
n'implémente pas l'interface Comparable ou pour définir un ordre de tri différent de celui défini avec
Comparable.

n Cette interface ne définit qu'une seule méthode: int compare(Object, Object)

n Cette méthode compare les deux objets fournis en paramètre et renvoie une:
q valeur entière négative si le premier objet est inférieur au second
q valeur entière positive si le premier objet est supérieur au second
q valeur nulle si les deux objets sont égaux

POO en java 39
Interface Comparator
§ Exemple avec Classe TreeMap
public int compare(String s1, String s2) {
int diff = [Link]() - [Link]();
if (diff != 0) {
import [Link];
return diff;
import [Link];
import [Link]; }
class ComparateurLongueur implements Comparator<String> { return [Link](s2);}
@Override
public int compare(String s1, String s2) {
return [Link]() - [Link]();}}

public class TestTreeMap { Ali : 14

public static void main(String[] args) { Omar : 15
Map<String, Integer> notes = new TreeMap<>(new ComparateurLongueur()); Sara : 16
[Link]("Ali", 14); Yassine : 12
[Link]("Omar", 15);
[Link]("Sara", 16);
[Link]("Yassine", 12); Ali : 14
Omar : 15
for ([Link]<String, Integer> entry : [Link]()) { Yassine : 12
[Link]([Link]() + " : " + [Link]());
}}}

POO en java 40
Remarque

Ø A ne pas confondre!

q Comparable et Comparator ne sont pas liés uniquement aux Map.

q Ils servent à définir comment comparer des objets.

q Ils sont utilisés partout où un tri est nécessaire.

POO en java 41
Synthèse

POO en java 42
Processus légers (threads)
Pr. AIT MAIT Hind

2025/2026
Threads

Introduction: processus

Traditionnellement, lorsqu’un programme est lancé, le système d’exploitation lui alloue

un processus.
Un processus est un contenant d’exécution qui comprend:
• le code du programme,
• les données (variables globales)
• les ressources
• le tas (heap) pour les allocations dynamiques,
• la pile (stack) pour stocker les variables locales
et les appels de fonctions.
• et les registres: contiennent les variables temporaires
et indiquent l’état des opérations effectuées.
Ø Chaque processus fonctionne indépendamment:
il possède sa propre mémoire, il ne partage rien avec les autres processus.

POO en JAVA 1
Threads

Introduction: processus

§ Les limites des processus

Cette séparation stricte garantit la sécurité et la stabilité, mais elle pose problème quand plusieurs parties
d’un même programme doivent coopérer rapidement.
• Chaque processus est lourd à créer (initialisation mémoire, registres, contexte…).
• La communication inter-processus (IPC) est lente et complexe.
• Le partage des données entre processus est difficile à gérer.
Ø Impossible d’exécuter plusieurs tâches en parallèle efficacement à l’intérieur d’un même programme.

POO en JAVA 2
Threads

Introduction: Du processus au thread et au multithreading

§ Pour surmonter les limites des processus, on a introduit la notion de thread,

aussi appelé processus léger.
Un thread est un sous-flux d’exécution appartenant à un même processus.
Plusieurs threads peuvent exister à l’intérieur d’un même processus,
ce qui permet l’exécution concurrente de plusieurs tâches.
Ø On parle alors de multithreading.
§ Il partage le code, les données et le tas du processus parent,
§ Mais il possède sa propre pile et ses propres registres.

POO en JAVA 3
Threads

Introduction: Du processus au thread et au multithreading

Grâce aux multithreading, un programme peut:

•Réagir plus vite aux interactions utilisateur,
•Effectuer plusieurs calculs simultanément.

Exemple: Application de messagerie (WhatsApp)

Un thread gère l’envoi des messages que l’utilisateur écrit.
Un autre s’occupe de mettre à jour l’interface (affichage des
contacts, notifications…).
Ø L’application reste fluide et réactive.

POO en JAVA 4
Threads

Thread en JAVA

A tout thread, Java associe:

- un objet qui détermine le code à exécuter par le thread;
- un objet qui « contrôle » le thread et le représente auprès des objets de l’application ; on l’appellera le
« contrôleur de thread ».
En Java, il existe, deux techniques pour créer un thread:
§ Soit vous dérivez votre thread de la classe: [Link],
§ soit vous implémentez l'interface: [Link].

POO en JAVA 5
Threads

Création de thread (1)

POO en JAVA 6
Threads

Création de thread (2)

POO en JAVA 7
Threads
Cycle de vie d’un thread

POO en JAVA 8
Threads
Cycle de vie d’un thread
Méthodes / Situation
État du thread Description
qui provoque cet état
Le thread vient d’être créé mais il n’a pas encore Création avec new
NEW
commencé son exécution. Thread()
Le thread est prêt à s’exécuter et attend que le processeur
RUNNABLE start()
(CPU) lui donne du temps d’exécution.
Le CPU sélectionne le
Le thread est actuellement en train d’exécuter la méthode
RUNNING thread parmi les threads
run().
Runnable

Le thread est bloqué car il attend l’accès à une ressource tentative d’accès à une
BLOCKED
utilisée par un autre thread (ex : section synchronized). ressource verrouillée

Le thread attend indéfiniment qu’un autre thread lui envoie

WAITING wait(), join()
un signal.
Le thread attend pendant une durée déterminée avant de
TIMED_WAITING sleep(time)
reprendre son exécution.
Le thread a terminé l’exécution de la méthode run() et ne
TERMINATED Fin de la méthode run()
peut plus être relancé.

POO en JAVA 9
Threads

Join() vs wait()

Méthode Signification Remarque

Permet à un thread d’attendre la
fin d’exécution d’un autre Utilisée pour coordonner
join()
thread avant de continuer son l’exécution des threads.
travail.
Cette méthode est utilisée dans
Permet à un thread de se mettre
les mécanismes de
wait() en attente jusqu’à ce qu’un autre
synchronisation (nous verrons
thread lui envoie un signal.
bientôt.).

POO en JAVA 10
Threads
Coordination des threads avec join(): Exemple (1)

class MonThread extends Thread {

private String nom;

public MonThread(String nom) {

[Link] = nom;
}

public void run() {

for(int i = 1; i <= 5; i++) {
[Link](nom + " : " + i);}}

POO en JAVA 11
Threads
Thread 2 : 1
Coordination des threads avec join(): Exemple (2) Thread 2 : 2 Thread 2 : 1
Thread 2 : 3 Thread 1 : 1
Thread 2 : 4 Thread 1 : 2
public class TestThread { Thread 2 : 5 Thread 1 : 3
Thread 1 : 1 Thread 1 : 1 Thread 1 : 4
public static void main(String[] args) throws Thread 1 : 2 Thread 1 : 2 Thread 1 : 5
InterruptedException{ Thread 1 : 3 Thread 1 : 3 Thread 2 : 2
Thread 1 : 4 Thread 1 : 4 Thread 2 : 3
MonThread t1 = new MonThread("Thread 1"); Thread 1 : 5
Thread 1 : 5 Thread 2 : 4
MonThread t2 = new MonThread("Thread 2"); Fin du Thread 2 : 1 Thread 2 : 5
[Link](); programme Thread 2 : 2 Fin du programme
principal Thread 2 : 3 principal
[Link](); Thread 2 : 4
[Link](); Thread 2 : 5
[Link](); Fin du
programme
[Link]("Fin du programme principal");}} principal

POO en JAVA 12
Threads

Coordination des threads avec join(): Exemple (3)

Thread 1 : 1
public class TestThread { Thread 1 : 2
public static void main(String[] args) throws Thread 1 : 3
InterruptedException{ Thread 1 : 4
Thread 1 : 5
MonThread t1 = new MonThread("Thread 1"); Thread 2 : 1
MonThread t2 = new MonThread("Thread 2"); Thread 2 : 2
[Link](); Thread 2 : 3
Thread 2 : 4
[Link](); Thread 2 : 5
[Link](); Fin du programme principal
[Link]();
[Link]("Fin du programme principal");}} Toujours le même résultat obtenu

POO en JAVA 13
Threads

Priorité des threads (1)

§ Chaque thread en Java possède une priorité qui peut influencer l’ordre dans lequel le processeur choisit
les threads à exécuter.
§ Un thread avec une priorité plus élevée a plus de chances d’être exécuté avant les autres.
§ Java définit trois niveaux principaux:

Constante Valeur
Thread.MIN_PRIORITY 1
Thread.NORM_PRIORITY 5
Thread.MAX_PRIORITY 10
§ La priorité d’un thread peut modifier avec la méthode: setPriority(int priority)
§ La priorité actuelle peut être consultée avec: getPriority()

POO en JAVA 14
Threads

Priorité des threads (2)

public class TestPriorite {
public static void main(String[] args) {
Thread t = new Thread();
[Link]("Priorité par défaut : " + [Link]());//5
[Link](Thread.MAX_PRIORITY);
[Link]("Nouvelle priorité : " + [Link]());//10
}
}

Ø La priorité influence seulement le planificateur du système, elle ne garantit pas l’ordre d’exécution des
threads.

POO en JAVA 15
Threads

problème des ressources partagées

Lorsque plusieurs threads accèdent en même temps à une même ressource partagée (variable, objet,
fichier), cela peut provoquer :
• des résultats incorrects
• des incohérences dans les données
• ce qu’on appelle une condition de concurrence (Race Condition)

Exemple: Deux threads modifient la même variable:

compteur = compteur + 1
-Comment garantir que les threads accèdent correctement aux ressources partagées?
Ø Solution: la synchronisation entre threads

POO en JAVA 16
Threads

Synchronisation des threads

§ La synchronisation est un mécanisme qui permet de contrôler l’accès aux ressources partagées lorsqu’un
programme utilise plusieurs threads.
§ La synchronisation repose sur trois notions importantes:

Concept Description
Partie du programme qui accède à une ressource
Section critique
partagée
Mécanisme qui contrôle l’accès à la section
Verrou (Lock)
critique
Un seul thread peut accéder à la section critique à
Exclusion mutuelle
la fois

Ø En Java, ce mécanisme est implémenté avec le mot-clé: synchronized

POO en JAVA 17
Threads

Synchronisation des threads: protection d’une ressource partagée (1)

Ø Protéger une section critique afin qu’un seul thread puisse l’exécuter à la fois.

Exemple: compteur partagé

class Compteur {
int valeur = 0;
public synchronized void incrementer() {
valeur++;
[Link]([Link]().getName() + " -> " + valeur);
}} class MonThread extends Thread {
Compteur compteur;
public MonThread(Compteur compteur, String nom) {
super(nom);
[Link] = compteur;}
public void run() {
for(int i = 0; i < 5; i++) {
[Link]();}}}
POO en JAVA 18
Threads

Synchronisation des threads: protection d’une ressource partagée (2)

Exemple: compteur partagé
public class TestSynchronisation {
Thread 1 -> 1
Thread 2 -> 2
public static void main(String[] args) throws
Thread 2 -> 3
InterruptedException {
Thread 2 -> 4
Compteur compteur = new Compteur(); Thread 1 -> 1
Thread 2 -> 5
MonThread t1 = new MonThread(compteur,"Thread 1"); Thread 1 -> 2
Thread 2 -> 6
MonThread t2 = new MonThread(compteur,"Thread 2"); Thread 1 -> 3
Thread 1 -> 7
Thread 1 -> 4
[Link](); Thread 1 -> 8
Thread 1 -> 5
[Link](); Thread 1 -> 9
Thread 2 -> 6
[Link](); Thread 1 -> 10
Thread 2 -> 7
[Link](); Thread 2 -> 8
}} Thread 2 -> 9
Thread 2 -> 10
Ø L’ordre d’exécution des threads peut varier selon le planificateur du système,
mais grâce à la synchronisation le résultat reste cohérent.
POO en JAVA 19
Threads

Synchronisation des threads: protection d’une ressource partagée (3)

Exemple: compteur partagé
Thread 2 -> 2
class Compteur { Thread 2 -> 3
int valeur = 0; Thread 2 -> 4
public void incrementer() { Thread 2 -> 5
Thread 2 -> 6
valeur++;
Thread 1 -> 1 Thread 1 -> 1
[Link]([Link]().getName() + " -> " Thread 1 -> 7 Thread 1 -> 3
+ valeur); Thread 1 -> 8 Thread 1 -> 4
}} Thread 1 -> 9 Thread 1 -> 5
Thread 1 -> 10 Thread 1 -> 6
Thread 2 -> 2
Thread 2 -> 7
Thread 2 -> 8
Ø Sans synchronisation, l’accès concurrent à la variable valeur provoque Thread 2 -> 9
Thread 2 -> 10
des résultats incohérents

POO en JAVA 20
Threads

Synchronisation des threads: Communication entre threads (1)

§ Dans certaines situations, les threads doivent se coordonner dans leur exécution.
Par exemple:
• Un thread doit attendre qu’une ressource soit disponible
• Un autre thread doit signaler que la ressource est prête
Dans ces cas, les threads doivent communiquer entre eux.
§ Java fournit les méthodes suivantes:
• wait(): met le thread en attente jusqu’à ce qu’un autre thread envoie un signal.
• notify(): réveille un thread qui est en attente.
• notifyAll(): réveille tous les threads en attente.

POO en JAVA 21
Threads

Synchronisation des threads: Communication entre threads (2)

§ Exemple: Producteur – Consommateur
class ZonePartagee {
int valeur;
boolean disponible = false;
public synchronized void produire(int v) throws InterruptedException
{
while(disponible) {
wait(); }
valeur = v;
[Link]("Produit : " + valeur);
disponible = true;
notify();}
public synchronized void consommer() throws InterruptedException {
while(!disponible) {
wait();}
[Link]("Consomme : " + valeur);
disponible = false;
POO en JAVA notify(); }} 22
Threads

Synchronisation des threads: Communication entre threads (3)

§ Exemple: Producteur – Consommateur
Thread Producteur Thread Consommateur
class Producteur extends Thread class Consommateur extends Thread
{ {
ZonePartagee zone; ZonePartagee zone;
public Producteur(ZonePartagee z) { public Consommateur(ZonePartagee z) {
zone = z; zone = z;
} }
public void run() { public void run() {
for(int i = 1; i <= 5; i++) { for(int i = 1; i <= 5; i++) {
[Link](i);} [Link]();}
} }
} }

POO en JAVA 23
Threads

Synchronisation des threads: Communication entre threads (4)

§ Exemple: Producteur – Consommateur

public class Main {

Produit : 1
public static void main(String[] args) { Consomme : 1
ZonePartagee zone = new ZonePartagee(); Produit : 2
Consomme : 2
Producteur p = new Producteur(zone); Produit : 3
Consommateur c = new Consommateur(zone); Consomme : 3
Produit : 4
[Link](); Consomme : 4
[Link](); Produit : 5
Consomme : 5
}
}

POO en JAVA 24
Threads
§ Exercice 1
class MonThread extends Thread {
private String nom;
public MonThread(String nom) {
[Link] = nom;}
public void run() {
for(int i=1;i<=3;i++) {
Q1: Est-ce que t2 est terminé avant "Fin" ?
[Link](nom + " : " + i);
Q2: Est-ce que join() impose l’ordre entre t1 et t2?
}}}
Q3: Qui attend ici ?
public class Test {
public static void main(String[] args) throws
InterruptedException {
MonThread t1 = new MonThread("T1");
MonThread t2 = new MonThread("T2");
[Link]();
[Link]();
[Link]();
[Link]("Fin");}}
POO en JAVA 25
Threads
§ Exercice 2
class MonThread extends Thread {
private String nom;
public MonThread(String nom) {
[Link] = nom;
}
public void run() {
for(int i=0;i<5;i++) { Q1: Est-ce que t1 commence toujours en premier ?
[Link](nom); Q2: La priorité garantit-elle l’ordre ?
}}}
public class TestPriorite {
public static void main(String[] args) {
MonThread t1 = new MonThread("T1");
MonThread t2 = new MonThread("T2");
[Link](10);
[Link](1);
[Link]();
[Link]();}}

POO en JAVA 26
Threads
§ Exercice 3
class ZonePartagee {
int valeur;
boolean disponible = false;
public synchronized void produire(int v) throws
InterruptedException {
while(disponible) {
wait();} Q1: Pourquoi while et pas if?
valeur = v;
Q2: Le producteur peut-il produire deux fois de suite?
[Link]("Produit : " + valeur);
disponible = true;
notify();}
public synchronized void consommer() throws
InterruptedException {
while(!disponible) {
wait();}
[Link]("Consomme : " + valeur);
disponible = false;
notify();}}

POO en JAVA 27
Les exceptions
Pr. AIT MAIT Hind

2025/2026
Exceptions

Introduction

Un programme informatique n’est pas toujours exécuté dans des conditions idéales. Lors de son exécution,
plusieurs situations imprévues peuvent survenir et perturber son fonctionnement normal.
Exemples de situations problématiques:
•Division par zéro lors d’un calcul
•Saisie incorrecte de l’utilisateur (ex : texte au lieu d’un nombre)
•Tentative d’accès à un fichier inexistant
•Etc…
Conséquences possibles
Ø Arrêt brutal du programme
Ø Affichage de messages d’erreur incompréhensibles
Ø Interruption du service offert à l’utilisateur

POO en JAVA 1
Exceptions

Introduction

Il est nécessaire de :
•détecter les erreurs lors de la compilation ou d l’exécution
•contrôler le comportement du programme
•éviter les arrêts brutaux
•informer l’utilisateur de manière claire
Ø ces situations sont appelées exceptions.

Une exception est un événement qui survient dans un programme et qui perturbe son
déroulement normal.

POO en JAVA 2
Exceptions
Hiérarchie des exceptions

POO en JAVA 3
Exceptions
Types des exceptions

1. Exceptions vérifiées (Checked Exceptions): sont des exceptions détectées au moment de la

compilation. Java oblige le programmeur à les gérer.
Exemples:
• Accès à un fichier inexistant: FileNotFoundException
• Problème lors d’une lecture de fichier: IOException

2. Exceptions Non vérifiées (Unchecked Exceptions): apparaissent pendant l’exécution du programme. Java
n’oblige pas le programmeur à les gérer.
Exemples:
• Division par zero: ArithmeticException
• Utilisation d’un objet non initialisé :NullPointerException

POO en JAVA 4
Exceptions
Gestion des exceptions
Au cœur de la gestion des exceptions en Java se trouvent cinq concepts clés : try, catch, finally, throw et throws.
Mot-clé Description

Le mot clé « try » est utilisé pour spécifier un bloc où

nous devons placer le code à risque. Le bloc « try » doit
try
être suivi par « catch » ou « finally ». Cela signifie que
nous ne pouvons pas utiliser le bloc « try » seul.

Le bloc « catch » est utilisé pour gérer l’exception. Il doit

être précédé par le bloc « try », ce qui signifie que nous
catch
ne pouvons pas utiliser le bloc « catch » seul. Il peut être
suivi par le bloc « finally ».
Le bloc « finally » est utilisé pour exécuter un code
finally important du programme. Il est exécuté dans tous les cas,
que l’exception soit levée ou non.
Le mot clé « throw » est utilisé pour lancer une exception
throw
de manière explicite.
Le mot clé « throws » est utilisé pour déclarer qu’une
throws méthode peut générer une exception. Il est utilisé dans la
signature de la méthode.
POO en JAVA 5
Exceptions
Gestion des exceptions
• Le bloc try-catch (1)
Ø permet de détecter et traiter une exception afin d’éviter l’arrêt du programme.

import [Link];
public class TestChecked {
1 error
public static void main(String[] args) {
ERROR!
§ Exemple: FileReader file = new FileReader("[Link]"); error: compilation failed
}}
import [Link];
import [Link];
public class TestChecked {
public static void main(String[] args) {
try { Erreur : fichier introuvable !
FileReader file = new FileReader("[Link]");
[Link]("Fichier ouvert avec succès");
} catch (IOException e) {
[Link]("Erreur : fichier introuvable !");
}}}
POO en JAVA 6
Exceptions
Gestion des exceptions
• Le bloc try-catch (2)

public class DemoDivision {

public static void main(String[] args) {
ERROR!
int a = 10, b = 0; Exception in thread
int res = a / b; "main”[Link]: / by zero
[Link]("Résultat : " + res); at [Link]([Link])
}}
§ Exemple:
public class DemoDivision{
public static void main(String[] args) {
int a = 10,b = 0;
try {
int res = a / b; Erreur : division par 0 !
[Link]("Résultat : " + res);
} catch (ArithmeticException e) {
[Link]("Erreur : division par 0 !");
}}}

POO en JAVA 7
Exceptions
Gestion des exceptions
• Le bloc try-catch (3)
try {
q Plusieurs blocs catch // code à risque
} catch (TypeException1 e) {
// traitement 1
} catch (TypeException2 e) {
// traitement 2
}
int a = 10, b = 0;
int[] tab = {1, 2, 3};
try {
int res = a / b;
[Link](tab[5]); Erreur : division par 0
§ Exemple: } catch (ArithmeticException e) {
[Link]("Erreur : division par 0");
} catch (ArrayIndexOutOfBoundsException e) {
[Link]("Erreur : indice invalide");
}
POO en JAVA 8
Exceptions
Gestion des exceptions
• Le bloc try-catch (4)
q Plusieurs blocs catch
Remarque: Lorsqu’on utilise plusieurs blocs catch, il faut faire attention à leur ordre.
Si une exception générale est placée avant une exception spécifique, cette dernière ne sera jamais
atteinte, ce qui provoque une erreur de compilation.

public class DemoErreurOrdre {

public static void main(String[] args) {
int a = 10, b = 0; ERROR!
try { error: compilation failed
§ Exemple:
int res = a / b;
} catch (Exception e) { ArithmeticException → Exception
[Link]("Erreur générale");
} catch (ArithmeticException e) {
[Link]("Erreur : division par 0");
} }}

POO en JAVA 9
Exceptions
Gestion des exceptions
• Le bloc try-catch + finally (1) § Exemple 1:

try { public class DemoFinallyMemoire {

// code à risque public static void main(String[] args) {
} catch (ExceptionType e) { String texte = new String("Données importantes");
// traitement de l'erreur try {
} finally { [Link]("Traitement des données...");
// toujours exécuté [Link]([Link]());
} int x = 10 / 0;
} catch (ArithmeticException e) {
Remarque: Les instructions dans le bloc [Link]("Erreur détectée");
finally sont souvent utilisées pour faire } finally {
des actions de « nettoyage » (ou de texte = null; // libération de la référence
libération de ressources), comme fermer [Link]("Mémoire libérée ");
un fichier ou une connexion réseau. }}}

Le bloc finally s’exécute dans tous les cas, qu’il y ait une exception ou non.
POO en JAVA 10
Exceptions
Gestion des exceptions
• Le bloc try-catch + finally (2) § Exemple 3:
§ Exemple 2: import [Link];
import [Link];
import [Link];
public class TestException{ public class TestException {
public static void main(String[] args) { public static void main(String[] args) throws IOException
File file = null; {
try{ try {
file = new File("[Link]"); FileReader f = new FileReader("[Link]");
[Link]([Link]()); [Link]("Fichier ouvert");
}finally{ } finally {
if (file != null) { [Link]("Bloc finally exécuté");
boolean supprime = [Link](; }}}
[Link]("Tentative de suppression :
" + supprime);}
}}}

POO en JAVA 11
Exceptions
Gestion des exceptions
• Throws (1)
Ø Le mot-clé throws permet de déclarer qu’une méthode peut générer une exception.
modificateur typeRetour nomMethode() throws ExceptionType {
// code
}

import [Link];
import [Link]; Ouverture du fichier...
public class DemoThrows { ERROR!
Exception in thread "main"
§ Exemple: public static void lireFichier() throws IOException {
[Link]: [Link]
[Link]("Ouverture du fichier..."); (No such file or directory)
FileReader f = new FileReader("[Link]");
[Link]("Fichier ouvert");
}
public static void main(String[] args) throws IOException {
lireFichier();
[Link]("Fin du programme");}}
POO en JAVA 12
Exceptions
Gestion des exceptions
• Throws (2)
§ Exemple:
catch (IOException e) {
try {
import [Link];
FileWriter fw = new FileWriter(nomFichier);
import [Link];
[Link]("Fichier créé automatiquement.");
import [Link];
[Link]();
public class DemoCreationFichier {
[Link]("Fichier créé avec succès !");
public static void lireFichier(String nom) throws
// réessayer après création
IOException {
lireFichier(nomFichier);
[Link]("Ouverture du fichier : " + nom);
} catch (IOException ex) {
FileReader f = new FileReader(nom);
[Link]("Erreur lors de la création du
[Link]("Fichier ouvert avec succès"); }
fichier");}
}
public static void main(String[] args) {
}
String nomFichier = "[Link]";
}
try {
lireFichier(nomFichier);
}
POO en JAVA 13
Exceptions

Les exceptions personnalisées (1)

Ø Une exception personnalisée est une exception créée par le programmeur pour gérer des cas spécifiques
à l’application.
class MonException extends Exception {
public MonException(String message) {
super(message);
}
}

public class Test {

public static void main(String[] args) throws MonException {
int age = 15;
if (age < 18) {
§ Exemple: throw new MonException("Age insuffisant");
}
}
}

POO en JAVA 14
Exceptions

Les exceptions personnalisées (2)

class MonException extends Exception {

public MonException(String message) {
super(message);}}
public class Test {
public static void main(String[] args) {
§ Exemple : int age = 15;
try {
if (age < 18) {
throw new MonException("Age insuffisant");
}
[Link]("Accès autorisé");
} catch (MonException e) {
[Link]([Link]());
}
[Link]("Fin du programme");}}

POO en JAVA 15
Exceptions
Exercice 1

String nom = null;

try {
[Link]([Link]());
} catch (NullPointerException e) { Q1. Quelle exception est générée ?
[Link]("Objet null !"); Q2. Est-ce que le bloc catch est exécuté ?
} finally { Q3. Est-ce que finally s’exécute ?
[Link]("Fin");
}

POO en JAVA 16
Exceptions
Exercice 2

int note = -5;

try {
if (note < 0) {
throw new IllegalArgumentException("Note
invalide"); Q1. Est-ce que l’exception est générée automatiquement
} ou manuellement ?
[Link]("Note valide"); Q2. Quel message sera affiché ?
} catch (IllegalArgumentException e) { Q3. Est-ce que "Note valide" sera affiché ?
[Link]("Erreur détectée");
}

POO en JAVA 17
Exceptions
Exercice 3

try {
String s = "abc"; Q1. Quelle exception est générée ?
int x = [Link](s); Q2. Est-ce que le programme compile?
} finally { Q3. Est-ce que finally s’exécute?
[Link]("Bloc finally");
}

POO en JAVA 18