Programmation Orientée Objet — Java | Prof.

Mohamed TIMMI

PROGRAMMATION ORIENTÉE
OBJET
☕ JAVA
Support de cours
Avec exemples d'application sur la classe Voiture

Prof. Mohamed TIMMI

Année Universitaire 2025/2026

Page 1 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Plan du Cours

1. Présentation générale de Java

• Syntaxe et compilation
• Machine virtuelle (JVM)
• Environnement d'exécution

2. Bases du langage
• Types primitifs et tableaux
• Références et affectation
• Structures de contrôle (conditionnelles et boucles)

3. Concepts de l'approche objet

• Objets et classes
• Encapsulation
• Héritage
• Abstraction et interfaces
• Polymorphisme

4. Programmation avancée
• Gestion des exceptions
• Entrées/Sorties en Java
• Structures de données : les collections
• Interfaces graphiques et gestion des événements

Page 2 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Partie 1 — Présentation générale de Java

1.1 Qu'est-ce que Java ?

Java est un langage de programmation orienté objet créé par Sun Microsystems en 1995. Il repose
sur quatre piliers fondamentaux :

Pilier Rôle
Classe & Objet Modéliser le monde réel
Encapsulation Protéger les données
Héritage Réutiliser le code
Polymorphisme S'adapter au contexte

💡 Java suit le principe "Write Once, Run Anywhere" : le même code s'exécute sur Windows,
Mac, Linux, Android, etc.

1.2 Syntaxe et compilation

En Java, le code source est compilé en bytecode (fichier .class), puis interprété par la JVM (Java
Virtual Machine). Il existe trois modes :

Mode Processus Portable Vitesse

Natif .java → .exe Non Très rapide
Bytecode .java → .class → Oui Lent
Interprétation
JIT (Just In Time) .java → .class → Oui Rapide
Compilation+Exécution

1.3 Premier programme Java

Règles importantes : le nom du fichier = nom de la classe, la classe principale est public, la
méthode main est le point d'entrée.

public class PremierProgramme {

public static void main(String[] args) {
[Link]("Bonjour Java !");
[Link]("Je programme mon premier cours !");
}
}

Page 3 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

1.4 Types primitifs en Java

Type Étendue Taille Exemple
byte -128 à +127 8 bits byte b = 100;
short -32 768 à +32 767 16 bits short s = 1000;
int -2 147 483 648 à +2 32 bits int i = 50;
147 483 647
long ± 9.2 × 10^18 64 bits long l = 100000L;
float ± 3.4E38 32 bits float f = 3.14f;
double ± 1.8E308 64 bits double d = 3.14;
char 0 à 65 535 (Unicode) 16 bits char c = 'A';
boolean true ou false 1 bit boolean ok = true;

1.5 Tableaux en Java

Un tableau stocke plusieurs valeurs de même type. Les indices commencent à 0.

// Déclaration et création
int[] notes = new int[5];
String[] noms = {"Alice", "Bob", "Mohamed"};

// Accès aux éléments

notes[0] = 15; // premier élément
notes[1] = 12; // deuxième élément

// Parcourir avec for-each

for (int note : notes) {
[Link]("Note : " + note);
}

1.6 Opérateurs et structures de contrôle

Opérateurs arithmétiques et logiques
int a = 10, b = 3;
[Link](a + b); // 13 (addition)
[Link](a - b); // 7 (soustraction)
[Link](a * b); // 30 (multiplication)
[Link](a / b); // 3 (division entière)
[Link](a % b); // 1 (modulo)

// Opérateurs logiques
boolean x = (a > 5) && (b < 10); // ET
boolean y = (a == 0) || (b == 0); // OU
boolean z = !(a > b); // NON

Page 4 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Structures conditionnelles
int vitesse = 130;

if (vitesse > 130) {

[Link]("Excès de vitesse grave");
} else if (vitesse > 90) {
[Link]("Excès de vitesse");
} else {
[Link]("Vitesse correcte");
}

Boucles
// Boucle for : nombre d'itérations connu
for (int i = 0; i < 5; i++) {
[Link]("Tour " + i);
}

// Boucle while : condition vérifiée avant

int carburant = 50;
while (carburant > 0) {
carburant -= 10;
[Link]("Carburant : " + carburant);
}

// Boucle do-while : exécutée au moins une fois

int km = 0;
do {
km++;
} while (km < 100);

// Boucle for-each : parcourir un tableau ou une collection

String[] couleurs = {"rouge", "bleue", "verte", "noire"};
for (String couleur : couleurs) {
[Link]("Voiture " + couleur);
}

// For-each sur un tableau d'objets Voiture

Voiture[] garage = {
new Voiture("rouge", 60, 120.0),
new Voiture("bleue", 40, 90.0),
new Voiture("verte", 55, 150.0)
};
for (Voiture v : garage) {
[Link](); // appelle demarrer() sur chaque voiture
}

Page 5 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Partie 2 — Objets et Classes

2.1 Qu'est-ce qu'un objet ?

Un objet est une entité qui regroupe à la fois des données (son état) et des actions (son
comportement). C'est la brique fondamentale de la Programmation Orientée Objet.
Dans la vie réelle, une voiture est un objet parfait pour illustrer ce concept :
• Son état : couleur, niveau de carburant, vitesse actuelle, cylindrée — des valeurs qui
décrivent la voiture à un instant donné
• Son comportement : démarrer, accélérer, freiner, klaxonner — des actions qu'elle peut
effectuer
• Son identité : chaque voiture est unique, même si deux voitures ont exactement le même
état

💡 En Java, chaque objet est stocké en mémoire à une adresse unique (sa référence). Deux
variables peuvent pointer vers le même objet, ou vers deux objets distincts ayant le même état.

État (attributs) Comportement (méthodes) Résultat

couleur = "rouge" demarrer() Le moteur se met en marche
carburant = 50 L accelerer(30) vitesse passe à 30 km/h,
carburant diminue
vitesse = 0 km/h freiner() vitesse réduite de 20 km/h
puissance = 120 ch klaxonner() Affiche "Tut tut !"

// Création de deux objets distincts à partir de la même classe

Voiture v1 = new Voiture("rouge", 60, 120.0);
Voiture v2 = new Voiture("bleue", 40, 90.0);

// Chaque objet a son propre état indépendant

[Link]([Link]()); // rouge
[Link]([Link]()); // bleue

// Agir sur v1 n'affecte jamais v2

[Link](); // seule v1 démarre
[Link](50); // seule v1 accélère
[Link]([Link]()); // 50.0
[Link]([Link]()); // 0.0 (v2 est inchangée)

2.2 Qu'est-ce qu'une classe ?

Une classe est le moule (ou plan de construction) à partir duquel on fabrique des objets. Elle décrit
:
• La structure : quels attributs (données) chaque objet possédera
• Le comportement : quelles méthodes (actions) chaque objet pourra exécuter

La distinction essentielle entre une classe et un objet peut se résumer ainsi :

• La classe contient les généralités : « toute voiture a une couleur, un carburant, et peut
démarrer »

Page 6 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

• L'objet contient les particularités : « cette voiture précise est rouge, a 60 L et est arrêtée »
• L'instanciation (mot-clé new) est l'acte de créer un objet concret à partir du moule que
représente la classe

Classe (abstrait) Objet (concret)

Plan de construction (blueprint) Réalisation concrète (instance)
Définit les attributs (noms et types) Possède des valeurs propres pour chaque
Décrit les méthodes (comportements) attribut
Existe en un seul exemplaire en mémoire Peut exécuter les méthodes définies
Ex: class Voiture { ... } On peut créer autant d'objets que nécessaire
Ex: new Voiture("rouge", 60, 120.0)

// La classe Voiture est définie UNE seule fois dans le code

// Mais on peut créer autant d'instances (objets) que l'on souhaite
Voiture maVoiture = new Voiture("rouge", 60, 120.0);
Voiture saVoiture = new Voiture("bleue", 40, 90.0);
Voiture notreVoiture = new Voiture("verte", 55, 150.0);

// Chaque objet est totalement indépendant des autres

[Link](); // seul maVoiture est concerné
[Link](50); // seul saVoiture accélère à 50 km/h
[Link]([Link]()); // 0.0 : inchangé

2.3 Déclaration d'une classe Java — Exemple Voiture

Voici la structure complète d'une classe Java bien conçue, respectant les bonnes pratiques
(encapsulation, constructeurs, getters/setters) :

public class Voiture {

// ── ATTRIBUTS (état de l'objet) ──────────────────────
private String couleur;
private int carburant;
private double puissance;
private boolean estDemarree;
private double vitesse;

// ── CONSTRUCTEUR ─────────────────────────────────────
public Voiture(String couleur, int carburant, double puissance) {
[Link] = couleur;
[Link] = carburant;
[Link] = puissance;
[Link] = false; // valeurs par défaut
[Link] = 0.0;
}

// ── MÉTHODES (comportement) ───────────────────────────

public void demarrer() {
if (!estDemarree) {
estDemarree = true;
[Link]("La voiture " + couleur + " démarre.");
} else {
[Link]("Voiture déjà démarrée.");
}
}

Page 7 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

public void accelerer(double v) {

if (estDemarree && carburant > 0) {
vitesse += v;
carburant -= 5;
[Link]("Vitesse : " + vitesse + " km/h");
} else if (!estDemarree) {
[Link]("Démarrez d'abord la voiture !");
} else {
[Link]("Plus de carburant !");
}
}

public void freiner() {

vitesse = [Link](0, vitesse - 20);
[Link]("Vitesse après freinage : " + vitesse + " km/h");
}

// ── GETTERS ───────────────────────────────────────────
public double getVitesse() { return vitesse; }
public String getCouleur() { return couleur; }
public int getCarburant() { return carburant; }
public boolean estDemarree() { return estDemarree; }

// ── SETTERS (avec validation) ─────────────────────────

public void setCouleur(String couleur) {
if (couleur != null && ![Link]()) {
[Link] = couleur;
}
}

public void setCarburant(int carburant) {

if (carburant >= 0) {
[Link] = carburant;
} else {
[Link]("Carburant invalide : valeur négative refusée.");
}
}

public void setVitesse(double vitesse) {

if (vitesse >= 0 && vitesse <= 300) {
[Link] = vitesse;
} else {
[Link]("Vitesse invalide : doit être entre 0 et 300
km/h.");
}
}
}

2.4 Constructeurs
Le constructeur initialise un objet lors de sa création. Il porte le même nom que la classe et n'a pas
de type de retour.

// Constructeur par défaut (sans paramètre)

public Voiture() {

Page 8 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

[Link] = "blanc";
[Link] = 50;
[Link] = 90.0;
[Link] = false;
}

// Constructeur avec paramètres

public Voiture(String couleur, int carburant, double puissance) {
[Link] = couleur;
[Link] = carburant;
[Link] = puissance;
}

// Surcharge : constructeur avec un seul paramètre

public Voiture(String couleur) {
this(couleur, 50, 90.0); // appel d'un autre constructeur
}

// Constructeur par copie : crée un objet identique à un autre

public Voiture(Voiture autre) {
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
}

// UTILISATION
Voiture v1 = new Voiture(); // défaut
Voiture v2 = new Voiture("rouge", 60, 110.0); // complet
Voiture v3 = new Voiture("bleue"); // partiel
Voiture v4 = new Voiture(v2); // copie de v2
// v4 est un objet distinct avec le même état que v2
// modifier v4 n'affecte PAS v2

⚠ Dès qu'un constructeur est défini, le constructeur par défaut de Java disparaît. Redéfinissez-le
explicitement si nécessaire.

2.5 L'objet courant — this

this est une référence implicite vers l'objet courant. Ses utilités principales :
• Distinguer attribut et paramètre de même nom
• Passer l'objet courant en paramètre
• Appeler un autre constructeur de la même classe

public void accelerer(double vitesse) {

// 'vitesse' seul → paramètre
// '[Link]' → attribut de l'objet
if (estDemarree) {
[Link] = [Link] + vitesse;
}
}

Page 9 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

2.6 Encapsulation
L'encapsulation est l'un des quatre piliers fondamentaux de la POO. Son principe : regrouper les
données (attributs) et les comportements (méthodes) au sein d'une même classe, tout en
protégeant les données internes de l'extérieur.
Concrètement, cela signifie :
• Déclarer tous les attributs en private : ils ne sont pas accessibles directement depuis
l'extérieur de la classe
• Fournir des méthodes publiques (getters/setters) pour lire ou modifier ces attributs de façon
contrôlée
• Valider les données dans les setters pour empêcher des états incohérents (ex : vitesse
négative, carburant = -10)

💡 Principe clé : « Cacher l'implémentation, exposer l'interface. » L'utilisateur de la classe ne sait

pas comment les données sont stockées en interne — il ne voit que ce qu'il peut faire avec l'objet.

Pourquoi encapsuler ? Voici les trois raisons fondamentales :

Raison Problème sans Solution avec encapsulation

encapsulation
Sécurité [Link] = -150; // valeur setVitesse(-150) → refusée
absurde acceptée avec message
Contrôle Aucune validation possible sur Le setter vérifie avant de
l'attribut modifier
Maintenabilité Changer le type de l'attribut Seul le getter/setter change,
casse tout le code l'API reste stable

Exemple concret — sans vs avec encapsulation :

// ✗ SANS encapsulation (dangereux) ─────────────────────

public class VoitureDangereuse {
public double vitesse; // attribut public : aucune protection
public int carburant;
}

VoitureDangereuse v = new VoitureDangereuse();

[Link] = -150; // accepté ! état incohérent
[Link] = -99; // accepté ! valeur impossible

// ✓ AVEC encapsulation (correct) ─────────────────────

public class Voiture {
private double vitesse; // caché : seule la classe peut y accéder
private int carburant;

public double getVitesse() { // lecture autorisée

return vitesse;
}

public void setVitesse(double vitesse) { // écriture contrôlée

if (vitesse >= 0 && vitesse <= 300) {
[Link] = vitesse; // acceptée
} else {
[Link]("Vitesse invalide : " + vitesse + " km/h");

Page 10 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

}
}

public void setCarburant(int carburant) {

if (carburant >= 0 && carburant <= 100) {
[Link] = carburant;
} else {
[Link]("Carburant hors limites.");
}
}
}

// Dans le main :
Voiture v = new Voiture("rouge", 60, 120.0);
// [Link] = -150; // ✗ Erreur de compilation : accès interdit
[Link](90); // ✓ Acceptée (0 <= 90 <= 300)
[Link](-50); // ✗ Refusée avec message d'erreur
[Link]([Link]()); // 90.0

Modificateur Classe elle- Sous-classe Même package Partout

même
private ✓ Oui ✗ Non ✗ Non ✗ Non
protected ✓ Oui ✓ Oui ✓ Oui ✗ Non
public ✓ Oui ✓ Oui ✓ Oui ✓ Oui
(aucun) ✓ Oui ✗ Non ✓ Oui ✗ Non

2.7 Variables et méthodes statiques

Une variable ou méthode statique (static) appartient à la classe elle-même, pas à une instance
particulière.
public class Voiture {
private static int nbVoituresCreees = 0; // partagée
public static final int VITESSE_MAX = 250; // constante

public Voiture(String couleur, int carburant, double puissance) {

// ... initialisation ...
nbVoituresCreees++; // incrémenté à chaque création
}

public static int getNbVoitures() {

return nbVoituresCreees;
}
}

// Accès sans instance :

[Link]([Link]()); // 0
Voiture v1 = new Voiture("rouge", 60, 120.0);
Voiture v2 = new Voiture("bleue", 40, 90.0);
[Link]([Link]()); // 2
[Link](Voiture.VITESSE_MAX); // 250

Page 11 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

2.8 Affectation et comparaison d'objets

Voiture v1 = new Voiture("rouge", 60, 110.0);
Voiture v2 = v1; // v2 référence le MÊME objet que v1
Voiture v3 = new Voiture("rouge", 60, 110.0); // objet distinct

[Link](v1 == v2); // true (même référence)

[Link](v1 == v3); // false (objets différents)

// Pour comparer le contenu, utiliser equals() :

[Link]([Link](v3)); // true si on la redéfinit

Page 12 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Partie 3 — Héritage

3.1 Définition et pourquoi l'héritage ?

L'héritage est un mécanisme qui permet à une classe (dite « fille » ou « sous-classe ») de
récupérer automatiquement tous les attributs et méthodes d'une autre classe (dite « mère » ou «
super-classe »), puis de l'étendre ou de la spécialiser.
L'héritage modélise une relation « est-un » :
• Une Voiture EST UN Vehicule → Voiture hérite de Vehicule
• Une Moto EST UN Vehicule → Moto hérite de Vehicule
• Un Camion EST UN Vehicule → Camion hérite de Vehicule

Pourquoi utiliser l'héritage ?

• Éviter la duplication de code : les attributs et méthodes communs (marque, vitesse,
demarrer()) sont écrits une seule fois dans la classe mère
• Favoriser la réutilisabilité : chaque classe fille bénéficie du code de la mère sans le réécrire
• Faciliter la maintenance : corriger un bug dans la mère corrige automatiquement toutes les
filles
• Permettre le polymorphisme : on peut manipuler toutes les filles via le type de la mère (voir
Partie 5)

💡 Règle Java : une classe ne peut hériter que d'UNE seule classe mère (héritage simple). En
revanche, elle peut implémenter plusieurs interfaces (voir Partie 4).

3.2 Sans héritage — le problème de duplication

Imaginons trois types de véhicules sans héritage. Les attributs marque et vitesse sont réécrits
dans chaque classe — c'est redondant, difficile à maintenir et source d'erreurs :
public class Voiture {
private String marque; // dupliqué dans chaque classe
private int vitesse; // dupliqué dans chaque classe
private int nbPortes; // spécifique à Voiture
// demarrer(), afficher()... aussi dupliqués !
}

public class Moto {

private String marque; // exactement le même code
private int vitesse; // exactement le même code
private boolean aSidecar; // spécifique à Moto
}

public class Camion {

private String marque; // encore une fois !
private int vitesse; // encore une fois !
private double chargeMax; // spécifique à Camion
}

⚠ Si on doit corriger la méthode demarrer(), il faudrait la modifier dans les 3 classes

séparément. Avec l'héritage, une seule modification dans la classe mère suffit.

Page 13 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

3.3 Avec héritage — mot-clé extends

On déplace le code commun dans une classe mère Vehicule. Les classes filles héritent
automatiquement de tout ce qui est déclaré protected ou public :
// ── Classe mère : contient tout ce qui est COMMUN ──────
public class Vehicule {
protected String marque; // hérité (accessible dans les filles)
protected int vitesse; // hérité
private String codeSecret; // NON hérité (private = invisible aux filles)

public Vehicule(String marque) { // constructeur de la mère

[Link] = marque;
[Link] = 0;
}

public void demarrer() { // méthode commune, héritée par toutes les filles
[Link](marque + " démarre.");
}

public void afficher() {

[Link]("Véhicule : " + marque + " | Vitesse : " + vitesse);
}
}

// ── Classe fille Voiture ─────────────────────────────────

public class Voiture extends Vehicule {
private int nbPortes; // attribut SPÉCIFIQUE à Voiture

public Voiture(String marque, int nbPortes) {

super(marque); // OBLIGATOIRE : appelle le constructeur de Vehicule
[Link] = nbPortes;
}

public void klaxonner() { // méthode SPÉCIFIQUE à Voiture

[Link](marque + " : Tut tut !");
}
}

// ── Classe fille Moto ────────────────────────────────────

public class Moto extends Vehicule {
private boolean aSidecar;

public Moto(String marque, boolean aSidecar) {

super(marque);
[Link] = aSidecar;
}

public void faireDeux_roues() {

[Link](marque + " fait une roue arrière !");
}
}

// ── TEST ─────────────────────────────────────────────────
Voiture v = new Voiture("Toyota", 5);
[Link](); // hérité de Vehicule → "Toyota démarre."
[Link](); // hérité de Vehicule → "Véhicule : Toyota | Vitesse : 0"
[Link](); // propre à Voiture → "Toyota : Tut tut !"

Page 14 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Moto m = new Moto("Yamaha", false);

[Link](); // hérité de Vehicule → "Yamaha démarre."

3.4 Modificateurs d'accès et héritage

Le choix du modificateur d'accès détermine ce que la classe fille peut voir et utiliser de la classe
mère :
Modificateur Dans la classe Classe fille Même package Partout
mère
private ✓ Visible ✗ Invisible ✗ Non ✗ Non
protected ✓ Visible ✓ Hérité et ✓ Oui ✗ Non
visible
public ✓ Visible ✓ Hérité et ✓ Oui ✓ Oui
visible
(aucun) ✓ Visible ✗ Non (sauf ✓ Oui ✗ Non
même package)

💡 Bonne pratique : déclarez les attributs protected dans la classe mère (plutôt que private) pour
qu'ils soient accessibles dans les classes filles sans passer par des getters.

3.5 Redéfinition de méthode — @Override

Une classe fille peut redéfinir (overrider) une méthode héritée pour lui donner un comportement
spécifique. La signature de la méthode doit être identique (même nom, mêmes paramètres).
Exemple : chaque véhicule démarre différemment — une voiture avec la clé, une moto au kick :
public class Vehicule {
public void demarrer() {
[Link]("Le véhicule démarre."); // comportement générique
}
}

public class Voiture extends Vehicule {

@Override // annotation recommandée
public void demarrer() { // même signature que dans Vehicule
[Link]("La voiture démarre avec la clé."); // spécialisé
}
}

public class Moto extends Vehicule {

@Override
public void demarrer() {
[Link]("La moto démarre au kick.");
}
}

// TEST :
Voiture v = new Voiture("Toyota", 5);
[Link](); // → "La voiture démarre avec la clé." (version redéfinie)

Page 15 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Moto m = new Moto("Harley", false);

[Link](); // → "La moto démarre au kick." (version redéfinie)

💡 @Override est optionnelle syntaxiquement, mais fortement conseillée : si la signature ne

correspond pas exactement à une méthode de la mère, le compilateur signale une erreur
immédiatement.

3.6 Le mot-clé super

super est une référence vers la classe mère. Elle a deux usages principaux :
• super(arguments) : appelle le constructeur de la classe mère — DOIT être la première
instruction du constructeur fille
• [Link]() : appelle la version de la méthode définie dans la classe mère, utile
pour l'étendre sans la remplacer complètement

public class Voiture extends Vehicule {

private int nbPortes;

public Voiture(String marque, int nbPortes) {

super(marque); // 1. initialise la partie Vehicule
[Link] = nbPortes; // 2. initialise ce qui est propre à Voiture
}

@Override
public void afficher() {
[Link](); // affiche "Véhicule : Toyota | Vitesse : 0"
[Link]("Nombre de portes : " + nbPortes); // ajoute "Nombre
de portes : 5"
}
}

// TEST :
Voiture v = new Voiture("Toyota", 5);
[Link]();
// Sortie :
// Véhicule : Toyota | Vitesse : 0
// Nombre de portes : 5

Page 16 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Partie 4 — Abstraction et Interfaces

4.1 Classes abstraites — définition

Une classe abstraite est une classe incomplète par conception : elle définit un modèle général
mais délègue certains comportements à ses sous-classes. Elle ne peut pas être instanciée
directement avec new.
Quand utiliser une classe abstraite ?
• Quand le concept représenté est trop vague pour être instancié directement : on n'a jamais
un « Vehicule » générique, mais toujours une voiture, une moto, un camion...
• Quand on veut forcer chaque sous-classe à implémenter certaines méthodes (marquées
abstract)
• Quand on veut partager du code commun (méthodes concrètes) tout en imposant des
méthodes à redéfinir

💡 Une classe abstraite peut contenir : des attributs d'instance, des constructeurs, des méthodes
concrètes (avec corps) ET des méthodes abstraites (sans corps). Si une seule méthode est
abstract, la classe doit l'être aussi.

// ── Classe abstraite ────────────────────────────────────

public abstract class Vehicule {
protected String marque;
protected int vitesse;

public Vehicule(String marque) { // constructeur : utilisable par les

filles
[Link] = marque;
[Link] = 0;
}

// Méthode ABSTRAITE : déclarée mais sans corps

// Chaque sous-classe DOIT l'implémenter, sinon erreur de compilation
public abstract void demarrer();

// Méthode CONCRÈTE : héritée telle quelle par toutes les sous-classes

public void afficherMarque() {
[Link]("Marque : " + marque);
}

// Autre méthode concrète commune

public void arreter() {
vitesse = 0;
[Link](marque + " est arrêté.");
}
}

// INTERDIT :
// Vehicule v = new Vehicule("Toyota"); // ✗ Erreur : classe abstraite

// ── Sous-classes concrètes ──────────────────────────────

public class Voiture extends Vehicule {
private int nbPortes;

public Voiture(String marque, int nbPortes) {

Page 17 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

super(marque);
[Link] = nbPortes;
}

@Override
public void demarrer() { // OBLIGATOIRE : implémente la méthode abstraite
[Link](marque + " démarre avec la clé.");
}
}

public class Moto extends Vehicule {

public Moto(String marque) {
super(marque);
}

@Override
public void demarrer() { // implémentation propre à Moto
[Link](marque + " démarre au kick.");
}
}

// TEST :
Voiture v = new Voiture("Renault", 5);
[Link](); // → "Renault démarre avec la clé."
[Link](); // hérité → "Marque : Renault"
[Link](); // hérité → "Renault est arrêté."

Moto m = new Moto("Kawasaki");

[Link](); // → "Kawasaki démarre au kick."

4.2 Interfaces — définition

Une interface est un contrat pur : elle déclare ce qu'une classe DOIT faire, sans dire comment.
Avant Java 8, une interface ne contenait que des constantes (static final) et des méthodes
abstraites. Elle ne peut pas être instanciée.
Différence fondamentale avec la classe abstraite :
• La classe abstraite partage du code (méthodes concrètes + abstrait) entre des classes
liées par une relation « est-un »
• L'interface définit uniquement un contrat (des capacités) que des classes non liées peuvent
toutes adopter
• Une classe peut hériter d'une seule classe mère, mais implémenter plusieurs interfaces
simultanément

💡 Exemple réel : une voiture et un avion ne partagent pas la même hiérarchie, mais tous deux
peuvent Rouler. Une voiture et un bateau peuvent tous deux Refaire le plein. Les interfaces
modélisent ces capacités transversales.

// ── Interfaces : définissent des CAPACITÉS ──────────────

public interface Roulant {
void rouler(); // public abstract implicitement
void freiner(); // toute classe Roulant doit pouvoir freiner
}

Page 18 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

public interface Klaxonnable {

void klaxonner();
}

public interface Electrique {

void recharger();
double getNiveauBatterie();
}

// ── Classe implémentant plusieurs interfaces ─────────────

public class VoitureElectrique extends Vehicule
implements Roulant, Klaxonnable, Electrique {

private double batterie; // niveau de batterie en %

public VoitureElectrique(String marque, double batterie) {

super(marque);
[Link] = batterie;
}

@Override public void demarrer() {

[Link](marque + " démarre silencieusement.");
}

@Override public void rouler() {

[Link](marque + " roule sur batterie.");
}

@Override public void freiner() {

[Link](marque + " freine (récupération d'énergie).");
}

@Override public void klaxonner() {

[Link](marque + " : Biiip !");
}

@Override public void recharger() {

batterie = 100;
[Link](marque + " chargée à 100%.");
}

@Override public double getNiveauBatterie() { return batterie; }

}

// TEST :
VoitureElectrique tesla = new VoitureElectrique("Tesla", 80);
[Link](); // → "Tesla démarre silencieusement."
[Link](); // → "Tesla roule sur batterie."
[Link](); // → "Tesla : Biiip !"
[Link](); // → "Tesla chargée à 100%."
[Link]("Batterie : " + [Link]() + "%"); // 100.0%

Page 19 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

4.3 Classe abstraite vs Interface — comparaison

Critère Classe abstraite Interface
Instanciation directe ✗ Impossible ✗ Impossible
Méthodes concrètes (avec ✓ Oui ✗ Non (avant Java 8)
corps)
Attributs d'instance ✓ Oui (protected, private...) ✗ Non (constantes static final
seulement)
Constructeur ✓ Oui (appelé via super()) ✗ Non
Héritage multiple ✗ Non (1 seule classe mère) ✓ Oui (plusieurs interfaces)
Relation modélisée Relation EST-UN (taxonomie) Relation PEUT-FAIRE
(capacité)
Mot-clé abstract class / extends interface / implements
Cas d'usage typique Partager du code entre Définir des contrats
classes liées transversaux

Règle de choix simple :

• Utilisez une classe abstraite quand les classes partagent du code ET ont une relation
hiérarchique forte (Vehicule → Voiture)
• Utilisez une interface quand vous définissez un comportement que des classes non liées
peuvent toutes adopter (Roulant, Klaxonnable, Electrique)

Page 20 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Partie 5 — Polymorphisme

5.1 Définition
Le mot « polymorphisme » vient du grec : polys (plusieurs) + morphé (forme). En POO, c'est la
capacité d'une référence à désigner des objets de types différents et d'adapter automatiquement
son comportement selon le type réel de l'objet pointé.
Plus simplement : un même message (appel de méthode) produit un résultat différent selon le type
réel de l'objet qui le reçoit.

Il existe deux formes principales de polymorphisme en Java :

• Polymorphisme de substitution (héritage) : une référence de type parent peut contenir un
objet de type enfant — c'est l'upcasting
• Polymorphisme d'interface : une référence de type interface peut contenir tout objet d'une
classe qui l'implémente

💡 Le mécanisme clé est la liaison tardive (late binding) : Java décide au moment de l'exécution
(et non à la compilation) quelle version de la méthode appeler, en fonction du type réel de l'objet.

// La référence est de type Vehicule (type de compilation)

// L'objet est de type Voiture (type réel à l'exécution)
Vehicule v = new Voiture("Toyota", 5);

// Java appellera la version de demarrer() de Voiture, pas de Vehicule

[Link](); // → "Toyota démarre avec la clé." (version Voiture)

5.2 Polymorphisme d'héritage — upcasting

L'upcasting consiste à stocker un objet d'une classe fille dans une variable du type de la classe
mère. C'est automatique (pas de cast explicite) et toujours sûr.
L'avantage majeur : on peut écrire du code générique qui fonctionne avec tous les sous-types.
Plus on ajoute de types de véhicules, plus le code s'enrichit sans modification :
// ── Toutes ces affectations sont valides (upcasting auto) ─
Vehicule v1 = new Voiture("Toyota", 5);
Vehicule v2 = new Moto("Yamaha");
Vehicule v3 = new VoitureElectrique("Tesla", 80);

// Java choisit la bonne version de demarrer() selon le type RÉEL

[Link](); // → "Toyota démarre avec la clé." (Voiture)
[Link](); // → "Yamaha démarre au kick." (Moto)
[Link](); // → "Tesla démarre silencieusement." (VoitureElectrique)

// ── Méthode générique exploitant le polymorphisme ───────

public static void inspecterVehicule(Vehicule v) {
[Link]("=== Inspection ===");
[Link](); // méthode concrète héritée
[Link](); // méthode polymorphe
[Link](); // méthode concrète héritée
}

// Fonctionne avec TOUS les types de Vehicule, présents ET futurs

Page 21 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

inspecterVehicule(new Voiture("BMW", 4));

inspecterVehicule(new Moto("Honda"));
inspecterVehicule(new VoitureElectrique("Tesla", 80));

// ── Tableau polymorphe ───────────────────────────────────

Vehicule[] flotte = {
new Voiture("Renault", 5),
new Moto("Kawasaki"),
new VoitureElectrique("Tesla", 90)
};

for (Vehicule v : flotte) {

[Link](); // chaque objet appelle SA version de demarrer()
}
// Sortie :
// Renault démarre avec la clé.
// Kawasaki démarre au kick.
// Tesla démarre silencieusement.

5.3 Downcasting — retour au type spécifique

L'upcasting perd l'accès aux méthodes spécifiques à la classe fille (ex : klaxonner() n'est pas dans
Vehicule). Pour y accéder, il faut caster la référence vers le type réel — c'est le downcasting.
Deux règles importantes :
• Le downcasting est EXPLICITE : on écrit (TypeFille) variable
• Il faut TOUJOURS vérifier avec instanceof avant de caster pour éviter une
ClassCastException à l'exécution

Vehicule v = new Voiture("Citroën", 4);

// [Link](); // ✗ Erreur de compilation : klaxonner() n'est pas dans

Vehicule

// ── Downcasting avec vérification (correct) ─────────────

if (v instanceof Voiture) { // vérifie le type réel
Voiture voiture = (Voiture) v; // cast explicite : sûr car vérifié
[Link](); // ✓ accessible maintenant
}

// ── Sans vérification (dangereux) ───────────────────────

Vehicule m = new Moto("Harley");
Voiture x = (Voiture) m; // ✗ ClassCastException ! Moto n'est pas une Voiture

// ── Traitement d'un tableau hétérogène ──────────────────

Vehicule[] flotte = {
new Voiture("Peugeot", 5),
new Moto("BMW"),
new Voiture("Audi", 4)
};

for (Vehicule veh : flotte) {

[Link](); // polymorphisme : toujours OK
if (veh instanceof Voiture) { // filtre les voitures
Voiture v2 = (Voiture) veh;

Page 22 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

[Link](); // spécifique aux voitures

}
}
// Sortie :
// Peugeot démarre avec la clé. | Peugeot : Tut tut !
// BMW démarre au kick.
// Audi démarre avec la clé. | Audi : Tut tut !

5.4 Polymorphisme avec interfaces

Une variable de type interface peut référencer tout objet d'une classe qui implémente cette
interface. Ce polymorphisme est encore plus puissant car il s'affranchit de la hiérarchie d'héritage.
// VoitureElectrique implémente Roulant et Klaxonnable
Roulant r = new VoitureElectrique("Tesla", 80);
[Link](); // → "Tesla roule sur batterie."
[Link](); // → "Tesla freine (récupération d'énergie)."
// [Link](); // ✗ klaxonner() n'est pas dans Roulant

Klaxonnable k = new VoitureElectrique("Rivian", 70);

[Link](); // → "Rivian : Biiip !"

// Méthode qui travaille sur n'importe quel objet Roulant

public static void faireRouler(Roulant r) {
[Link]();
[Link]();
}

// Utilisable avec toute classe implémentant Roulant :

faireRouler(new VoitureElectrique("Tesla", 80));
// faireRouler(new Trottinette(...)); // si Trottinette implements Roulant

5.5 Résumé — Avantages du polymorphisme

Avantage Description Exemple concret
Flexibilité Ajout de nouveaux types sans Ajouter Camion extends
modifier le code existant Vehicule : inspecterVehicule()
fonctionne automatiquement
Réutilisabilité Une seule méthode générique inspecterVehicule(Vehicule v)
fonctionne pour tous les sous- traite Voiture, Moto, Camion...
types
Maintenabilité Respect du principe OCP Nouveau type → pas de
(ouvert à l'extension, fermé à modification du code existant
la modification)
Lisibilité Code plus concis, moins de Boucle for-each sur un tableau
if/else sur les types Vehicule[] unifié

Page 23 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Partie 6 — Gestion des Exceptions

6.1 Qu'est-ce qu'une exception ?

Une exception est un événement anormal qui interrompt le déroulement normal d'un programme.
Java gère les exceptions via un mécanisme try-catch-finally.

Exception courante Cause

NullPointerException Accès à un objet null
ArrayIndexOutOfBoundsException Indice de tableau hors limites
ClassCastException Cast invalide entre types
ArithmeticException Division par zéro
NumberFormatException Conversion de chaîne invalide en nombre

6.2 try-catch-finally
public class TestVoiture {
public static void main(String[] args) {
Voiture[] garage = new Voiture[3];
garage[0] = new Voiture("rouge", 60, 120.0);
// garage[1] et garage[2] sont null

try {
for (Voiture v : garage) {
[Link](); // NullPointerException si v == null
}
} catch (NullPointerException e) {
[Link]("Erreur : voiture non initialisée !");
} catch (Exception e) {
[Link]("Erreur inattendue : " + [Link]());
} finally {
[Link]("Fin de la vérification du garage.");
}
}
}

6.3 Lancer une exception — throw

public void setVitesse(double vitesse) {
if (vitesse < 0 || vitesse > 300) {
throw new IllegalArgumentException(
"Vitesse invalide : " + vitesse + " km/h");
}
[Link] = vitesse;
}

// Utilisation :
try {
[Link](500);
} catch (IllegalArgumentException e) {

Page 24 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

[Link]([Link]());
// "Vitesse invalide : 500.0 km/h"
}

6.4 Exception personnalisée

// Création d'une exception spécifique au domaine automobile
public class CarburantInsuffisantException extends Exception {
public CarburantInsuffisantException(String message) {
super(message);
}
}

// Utilisation dans Voiture :

public void accelerer(double v) throws CarburantInsuffisantException {
if (carburant <= 0) {
throw new CarburantInsuffisantException(
"Plus de carburant ! Impossible d'accélérer.");
}
vitesse += v;
carburant -= 5;
}

// Dans le main :
try {
[Link](30);
} catch (CarburantInsuffisantException e) {
[Link]([Link]());
}

Page 25 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Partie 7 — Entrées / Sorties en Java

7.1 Lecture au clavier — Scanner

import [Link];

public class SaisieVoiture {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);

[Link]("Entrez la couleur : ");

String couleur = [Link]();

[Link]("Entrez la puissance (ch) : ");

double puissance = [Link]();

[Link]("Entrez le carburant (L) : ");

int carburant = [Link]();

Voiture v = new Voiture(couleur, carburant, puissance);

[Link]("Voiture créée : " + couleur);

[Link]();
}
}

7.2 Écriture dans un fichier

import [Link].*;

public class SauvegardeVoiture {

public static void sauvegarder(Voiture v, String fichier) {
try (PrintWriter pw = new PrintWriter(
new FileWriter(fichier, true))) {
[Link]([Link]() + "," + [Link]()
+ "," + [Link]());
[Link]("Voiture sauvegardée dans " + fichier);
} catch (IOException e) {
[Link]("Erreur d'écriture : " + [Link]());
}
}
}

7.3 Lecture d'un fichier

import [Link].*;

public class LectureVoitures {

public static void lire(String fichier) {
try (BufferedReader br = new BufferedReader(
new FileReader(fichier))) {
String ligne;

Page 26 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

while ((ligne = [Link]()) != null) {

String[] parts = [Link](",");
String couleur = parts[0];
int carburant = [Link](parts[1]);
double puissance = [Link](parts[2]);
Voiture v = new Voiture(couleur, carburant, puissance);
[Link]("Chargé : " + couleur);
}
} catch (IOException e) {
[Link]("Erreur de lecture : " + [Link]());
}
}
}

Page 27 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Partie 8 — Structures de données : les Collections

8.1 Vue d'ensemble

Les collections Java (package [Link]) permettent de stocker des ensembles d'objets de manière
dynamique, contrairement aux tableaux à taille fixe.
Collection Caractéristiques Utilisation typique
ArrayList<E> Liste ordonnée, doublons Liste de voitures, historique
autorisés, accès par indice
LinkedList<E> Liste chaînée, insertions File d'attente au garage
rapides en début/fin
HashSet<E> Ensemble non ordonné, pas Ensemble de marques uniques
de doublons
TreeSet<E> Ensemble trié, pas de Classement par vitesse
doublons
HashMap<K,V> Paires clé-valeur, accès rapide Annuaire
par clé immatriculation→voiture
TreeMap<K,V> Paires clé-valeur triées Classement trié

8.2 ArrayList — exemple avec Voiture

import [Link];
import [Link];

public class Garage {

private ArrayList<Voiture> voitures = new ArrayList<>();

public void ajouterVoiture(Voiture v) {

[Link](v);
[Link]("Voiture ajoutée. Total : " + [Link]());
}

public void retirerVoiture(int index) {

[Link](index);
}

public void afficherToutes() {

for (Voiture v : voitures) {
[Link]([Link]() + " - " + [Link]() + "
km/h");
}
}

public static void main(String[] args) {

Garage g = new Garage();
[Link](new Voiture("rouge", 60, 120.0));
[Link](new Voiture("bleue", 40, 90.0));
[Link](new Voiture("verte", 55, 150.0));
[Link]();
}
}

Page 28 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

8.3 HashMap — immatriculation → Voiture

import [Link];

public class RegistreVehicules {

private HashMap<String, Voiture> registre = new HashMap<>();

public void enregistrer(String immat, Voiture v) {

[Link](immat, v);
}

public Voiture rechercher(String immat) {

return [Link](immat); // null si non trouvée
}

public void afficherTout() {

for (String immat : [Link]()) {
Voiture v = [Link](immat);
[Link](immat + " → " + [Link]());
}
}

public static void main(String[] args) {

RegistreVehicules r = new RegistreVehicules();
[Link]("AB-123-CD", new Voiture("rouge", 60, 120.0));
[Link]("EF-456-GH", new Voiture("bleue", 40, 90.0));

Voiture found = [Link]("AB-123-CD");

[Link]("Trouvée : " + [Link]()); // rouge
}
}

Page 29 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Partie 9 — Interfaces Graphiques (Swing)

9.1 Introduction à Swing

Swing est la bibliothèque Java pour créer des interfaces graphiques (fenêtres, boutons, champs de
texte, etc.). Les composants principaux sont :
• JFrame : fenêtre principale
• JPanel : conteneur de composants
• JLabel : étiquette de texte
• JTextField : champ de saisie
• JButton : bouton cliquable
• JComboBox : liste déroulante

9.2 Fenêtre de gestion de voiture

import [Link].*;
import [Link].*;
import [Link].*;

public class FenetreVoiture extends JFrame {

private JTextField champCouleur;
private JTextField champPuissance;
private JTextField champCarburant;
private JLabel labelStatut;
private Voiture voiture;

public FenetreVoiture() {
setTitle("Gestion de Voiture");
setSize(400, 300);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new GridLayout(5, 2, 10, 10));

add(new JLabel("Couleur :"));

champCouleur = new JTextField();
add(champCouleur);

add(new JLabel("Puissance (ch) :"));

champPuissance = new JTextField();
add(champPuissance);

add(new JLabel("Carburant (L) :"));

champCarburant = new JTextField();
add(champCarburant);

JButton btnCreer = new JButton("Créer la voiture");

[Link](new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
creerVoiture();
}
});
add(btnCreer);

JButton btnDemarrer = new JButton("Démarrer");

Page 30 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

[Link](e -> demarrerVoiture());

add(btnDemarrer);

labelStatut = new JLabel("Statut : en attente");

add(labelStatut);

setVisible(true);
}

private void creerVoiture() {

try {
String couleur = [Link]();
double puissance = [Link]([Link]());
int carburant = [Link]([Link]());
voiture = new Voiture(couleur, carburant, puissance);
[Link]("Voiture créée : " + couleur);
} catch (NumberFormatException ex) {
[Link](this,
"Valeurs numériques invalides !", "Erreur",
JOptionPane.ERROR_MESSAGE);
}
}

private void demarrerVoiture() {

if (voiture != null) {
[Link]();
[Link]("Statut : démarrée !");
} else {
[Link](this,
"Créez d'abord une voiture !", "Info",
JOptionPane.INFORMATION_MESSAGE);
}
}

public static void main(String[] args) {

[Link](() -> new FenetreVoiture());
}
}

9.3 Gestion des événements

La gestion des événements repose sur le patron de conception Écouteur (Listener). Pour chaque
action utilisateur, on attache un listener au composant.
Événement Interface Listener Méthode
Clic sur bouton ActionListener actionPerformed(ActionEvent
e)
Frappe clavier KeyListener keyPressed(KeyEvent e)
Souris MouseListener mouseClicked(MouseEvent e)
Fermeture fenêtre WindowListener windowClosing(WindowEvent
e)
Sélection liste ListSelectionListener valueChanged(...)

Page 31 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

// Avec classe anonyme (ancienne syntaxe)

[Link](new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
[Link]();
}
});

// Avec expression lambda (Java 8+, syntaxe moderne)

[Link](e -> [Link]());

Page 32 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Annexe — Récapitulatif et Exemple Complet

Hiérarchie complète des classes

// Interface
public interface Roulant {
void rouler();
}

// Classe abstraite mère

public abstract class Vehicule implements Roulant {
protected String marque;
private static int nbVehicules = 0;

public Vehicule(String marque) {

[Link] = marque;
nbVehicules++;
}

public abstract void demarrer();

@Override
public void rouler() {
[Link](marque + " roule.");
}

public static int getNbVehicules() { return nbVehicules; }

}

// Classe concrète
public class Voiture extends Vehicule {
private int nbPortes;
private double vitesse;
private int carburant;
private boolean estDemarree;

public Voiture(String marque, int nbPortes, int carburant) {

super(marque);
[Link] = nbPortes;
[Link] = carburant;
[Link] = 0;
[Link] = false;
}

@Override
public void demarrer() {
estDemarree = true;
[Link](marque + " démarre (clé).");
}

public void accelerer(double v) {

if (estDemarree && carburant > 0) { vitesse += v; carburant -= 3; }
}

public void freiner() { vitesse = [Link](0, vitesse - 20); }

public double getVitesse() { return vitesse; }
public String getMarque() { return marque; }

Page 33 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Programme de démonstration
public class Demo {
public static void main(String[] args) {
// Création polymorphe
Vehicule[] flotte = {
new Voiture("Renault", 5, 60),
new Voiture("Peugeot", 4, 40),
};

[Link]("=== Démarrage de la flotte ===");

for (Vehicule v : flotte) {
[Link](); // polymorphisme
[Link](); // méthode de l'interface
}

[Link]("\n=== Accélération ===");

if (flotte[0] instanceof Voiture) {
Voiture v = (Voiture) flotte[0]; // downcasting
[Link](50);
[Link](30);
[Link]("Vitesse : " + [Link]() + " km/h");
[Link]();
[Link]("Après freinage : " + [Link]() + " km/h");
}

[Link]("\nTotal véhicules créés : " +

[Link]());
}
}

Tableau récapitulatif des concepts POO

Concept Mot-clé Java Description Exemple Voiture
Classe class Modèle de données class Voiture { }
et comportements
Objet new Instance concrète new Voiture("rouge", 60,
d'une classe 120)
Encapsulation private/public Protection des private double vitesse
données internes
Getter/Setter (aucun) Accès contrôlé aux getVitesse(), setVitesse()
attributs
Héritage extends Réutilisation entre class Voiture extends
classes Vehicule
Redéfinition @Override Spécialisation d'une @Override demarrer()
méthode
Super super Accès à la classe super(marque);
mère [Link]()

Page 34 / 35 — Année Universitaire 2025/2026

Programmation Orientée Objet — Java | Prof. Mohamed TIMMI

Abstraction abstract Modèle sans abstract void demarrer()

instanciation directe
Interface interface/implements Contrat de implements Roulant
comportements
Polymorphisme (upcasting) Référence parent → Vehicule v = new
objet enfant Voiture(...)
Static static Appartient à la static int nbVoitures
classe, pas à l'objet
Exception try/catch/throw Gestion des erreurs throw new
IllegalArgumentException

Prof. Mohamed TIMMI — Année Universitaire 2025/2026

Page 35 / 35 — Année Universitaire 2025/2026