Fiche de révision : 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

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.