Ficha de revisão: Introduction à la Programmation Orientée Objet en Java

1. 📌 L'essentiel

• La POO modélise objets via classes, regroupant données et comportements.
• Concepts clés : classes, objets, héritage, polymorphisme, encapsulation, abstraction.
• Une classe est un plan, un une instance concrète.
• Constructeur : méthode d'initialisation automatique ou personnalisée.
• Encapsulation : contrôle d'accès via public, protected, private.
• Polymorphisme : redéfinition de méthodes dans classes filles (@Override).
• Héritage : extends pour transmettre attributs/méthodes.
• Interfaces : contrats sans implémentation, implements.
• Singleton : pattern pour une seule instance d'une classe.
• Relations UML : association, héritage, implémentation, agrégation.

2. 🧩 Structures & Composants clés

• Classe — modèle définissant attributs et méthodes.
• Objet — instance concrète d'une classe.
• Constructeur — initialise un objet lors de sa création.
• Attributs — variables représentant l’état d’un objet.
• Méthodes — comportements ou actions d’un objet.
• Héritage (extends) — transmission de fonctionnalités.
• Interface — contrat définissant des méthodes à implémenter.
• Encapsulation — visibilités : public, protected, private.
• Polymorphisme — méthodes redéfinies dans classes filles.
• Abstraction — classes ou méthodes abstraites (abstract).

3. 🔬 Fonctions, Mécanismes & Relations

• La classe sert de plan, l’objet est une instance concrète.
• Constructeur : méthode d'initialisation, implicite non défini.
• Surcharge : plusieurs méthodes ou constructeurs avec même nom, paramètres différents.
• static : attributs ou méthodes liés à la classe, partagés par toutes les instances.
• Singleton : contrôle d’une seule instance via méthode statique (getInstance()).
• Héritage (extends) : permet la réutilisation et la spécialisation.
• Polymorphisme : appel dynamique selon le type réel de l’objet.
• Encapsulation : private pour attributs, accès via getters/setters.
• Abstraction : classes ou méthodes abstraites (abstract) pour définir des comportements.
• Interface : définit un contrat, classes l’implémentent.
• Relations UML : association (utilisation), héritage (extends), implémentation (implements), agrégation.

4. Tableau comparatif

Élément	Caractéristiques clés	Notes / Différences
Classe	Plan, attributs, méthodes, constructeur	Instance créée par new
Objet	Instance d'une classe, avec état et comportement	Créé via new
Surcharge	Même nom, paramètres différents	Méthodes ou constructeurs
Static	Attributs/méthodes liés à la classe	Partagés entre toutes les instances
Singleton	Instance unique, contrôlée par méthode statique	private static instance, getInstance()
Héritage (extends)	Transmission attributs/méthodes, super() pour appel constructeur	Classe fille hérite de classe mère
Polymorphisme	Redéfinition de méthodes, appel dynamique	@Override, méthodes virtuelles
Encapsulation	Visibilité (public, protected, private)	Contrôle d’accès
Abstraction	Classes ou méthodes abstraites (abstract)	Ne peuvent pas être instanciées, définissent un contrat
Interface	Contrat de méthodes sans implémentation, implements	Classes concrètes doivent l’implémenter
Relations UML	Association, héritage, implémentation, agrégation	Représentations graphiques du modèle

5. 🗂️ Diagramme hiérarchique ASCII

Classe
 ├─ Attributs
 ├─ Méthodes
 ├─ Constructeur
 └─ Héritage (extends)
 
Objet
 └─ Instance d'une classe

Héritage
 ├─ Classe mère
 └─ Classe fille (extends)

Polymorphisme
 └─ Redéfinition de méthodes (`@Override`)

Encapsulation
 ├─ public
 ├─ protected
 └─ private

6. ⚠️ Pièges & confusions fréquentes

• Confondre héritage (extends) et composition.
• Oublier d’implémenter toutes les méthodes d’une interface.
• Confondre static et instance.
• Mauvaise utilisation de private et getters/setters.
• Négliger le rôle de l’abstraction dans la conception.
• Confusion entre surcharge et redéfinition.
• Oublier super() dans le constructeur de classe fille.
• Confondre agrégation et composition.
• Ne pas respecter le contrat d’une interface.

7. ✅ Checklist pour l’examen

• Définir une classe, un objet, un constructeur.
• Expliquer la différence entre surcharge et redéfinition.
• Décrire le rôle de static et du singleton.
• Expliquer l’héritage (extends) et le polymorphisme.
• Préciser la différence entre encapsulation et abstraction.
• Connaître les relations UML principales.
• Savoir utiliser interface et implements.
• Identifier les visibilités (public, protected, private).
• Savoir créer une classe abstraite.
• Comprendre le fonctionnement d’un singleton.
• Représenter une hiérarchie simple en ASCII.