Revision sheet: Architecture Logicielle Orientée Objets

1. 📌 L'essentiel

• Opérateur new : réserve mémoire JVM, initialise avec valeurs par défaut.
• Héritage : supporté via classes et interfaces, non multiple pour classes en Java.
• Classe abstraite ne peut pas être instanciée, peut contenir méthodes abstraites.
• Pattern Singleton : garantit une seule instance d’une classe.
• Pattern Builder : construit des objets complexes en dissociant construction et représentation.
• Méthode finalize() : appelée par le Garbage Collector, signature « public void finalize(); ».
• Relations entre classes : héritage, agrégation, composition, association.
• Pattern décorateur : ajoute dynamiquement des responsabilités.
• **Pattern état : gère plusieurs états d’un objet pour simplifier la logique.
• Modèle MVC : sépare données, interface et logique de traitement.
• Typage fort : erreurs détectées à la compilation, documentation automatique.
• UML : modélise classes, relations, principes POO.
• Gestion bibliothèque : modélisation ouvrages, abonnés, emprunts, réservations, notifications.

2. 🧩 Structures & Composants clés

• Classe : modèle d’objet avec attributs et méthodes.
• Interface : contrat sans implémentation, supporte l’extension multiple.
• Héritage : relation « est-un » permettant la réutilisation.
• Composition : relation forte, l’objet possède ses composants.
• Agrégation : relation faible, composants peuvent exister indépendamment.
• Pattern Singleton : classe avec instance unique accessible globalement.
• Pattern Builder : classe séparée pour construire un objet complexe.
• Pattern décorateur : classe qui enveloppe une autre pour ajouter des responsabilités.
• Pattern état : gestion des états internes d’un objet.
• Pattern MVC : architecture en trois composants (Modèle, Vue, Contrôleur).
• Relations UML : héritage (flèche pleine), association (ligne simple), agrégation (ligne avec losange), composition (ligne avec losange noir).

3. 🔬 Fonctions, Mécanismes & Relations

• new : alloue mémoire et initialise par défaut.
• super : référence à la classe mère, utilisée pour appeler le constructeur ou méthodes parent.
• finalize() : libère ressources, appelée lors de la suppression par GC.
• Classes abstraites : définissent des méthodes abstraites à implémenter dans les sous-classes.
• Héritage : permet la réutilisation, mais pas multiple pour classes en Java.
• Interfaces : extension multiple, définissent des contrats sans implémentation.
• Pattern Singleton : contrôle la création d’une seule instance via un constructeur privé.
• Pattern Builder : facilite la création d’objets avec arguments optionnels.
• Pattern décorateur : enveloppe un objet pour ajouter des responsabilités sans modifier la classe d’origine.
• Relations : héritage (structure « est-un »), agrégation (relation faible), composition (relation forte), association (relation dynamique).
• Pattern état : modélise différents comportements selon l’état de l’objet.
• UML : représente la structure statique et dynamique du système.

4. Tableau comparatif des relations entre classes

Élément	Caractéristiques clés	Notes / Différences
Héritage	« est-un », réutilise code, supporte polymorphisme	Simple, unique en Java, support interfaces
Agrégation	Relation faible, composants indépendants	Ex : classe « Voiture » et « Roue »
Composition	Relation forte, composants dépendants	Ex : « Maison » et « Pièce »
Association	Relation dynamique, peut être bidirectionnelle	Ex : « Étudiant » et « Cours »

5. 🗂️ Diagramme Hiérarchique ASCII

Architecture Orientée Objets
 ├─ Classes
 │    ├─ Classe concrète
 │    ├─ Classe abstraite
 │    └─ Interface
 ├─ Relations
 │    ├─ Héritage
 │    ├─ Agrégation
 │    └─ Composition
 ├─ Patterns
 │    ├─ Singleton
 │    ├─ Builder
 │    ├─ Decorateur
 │    ├─ État
 │    └─ MVC
 └─ Modélisation UML
      ├─ Classes
      └─ Relations

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

• Confondre héritage et composition.
• Oublier que Java ne supporte pas l’héritage multiple de classes.
• Confondre agrégation et composition.
• Utiliser finalize() sans nécessité, car elle est dépréciée en Java moderne.
• Mal distinguer interface et classe abstraite.
• Confondre pattern Singleton avec simple classe utilitaire.
• Omettre de rendre le constructeur privé dans Singleton.
• Confondre pattern décorateur et héritage simple.
• Négliger la gestion des états dans le pattern état.
• Ignorer la séparation MVC lors de la modélisation.
• Mal représenter UML (flèches, losanges).

7. ✅ Checklist Examen Final

• Définir l’opérateur new et ses effets.
• Expliquer la différence entre classe abstraite et interface.
• Décrire le pattern Singleton et son implémentation.
• Illustrer le pattern Builder avec un exemple.
• Expliquer la méthode finalize() et son rôle.
• Distinguer héritage, agrégation, composition.
• Définir le pattern décorateur.
• Expliquer le pattern état.
• Présenter le modèle MVC.
• Représenter une relation UML d’héritage.
• Identifier les principes fondamentaux de la POO (encapsulation, héritage, polymorphisme).
• Modéliser une hiérarchie d’objets dans une gestion de bibliothèque.
• Décrire comment UML facilite la conception.
• Citer des patterns pour la conception modulaire.
• Expliquer la gestion des notifications dans le pattern observateur.
• Illustrer l’utilisation de l’interface web avec MVC.

Fin de la fiche. Bonne révision !