Hoja de repaso: Introduction à la Programmation Orientée Objet

📌 L'essentiel

• La Programmation Orientée Objet (POO) modélise le monde réel via des classes et objets.
• Concepts centraux : classes, objets, encapsulation, héritage, polymorphisme, abstraction.
• Respect du principe SOLID pour une conception robuste, lisible et maintenable.
• UML pour la modélisation : diagrammes de classes et de séquences.
• Patrons de conception courants : Strategy, Observer, Factory.
• Gestion d’erreurs via exceptions et invariants.
• Méthodes spéciales (str, eq, etc.) pour définir le comportement d’objets.
• Sérialisation (JSON, bases légères) pour la persistance.
• Architecture modulaire avec inversion de dépendances (Ports & Adapters).

📖 Concepts clés

Classe : Modèle ou plan de construction d’un objet, définissant ses attributs et comportements.

Objet : Instance concrète d’une classe, représentant une entité spécifique.

Encapsulation : Principe de protection de l’état interne d’un objet en limitant l’accès direct.

Héritage : Mécanisme permettant de créer une classe dérivée à partir d’une classe existante, réutilisant ses propriétés et méthodes.

Polymorphisme : Capacité pour différentes classes d’avoir des méthodes portant le même nom mais avec des implementations différentes.

Abstraction : Définition d’une interface ou d’un contrat sans implémentation concrète, pour cacher les détails complexes.

Patrons de conception : Solutions réutilisables pour des problématiques communes en POO (ex : Singleton, Observer).

SOLID : Ensemble de principes pour une conception évolutive et facilement maintenable :

• Responsabilité unique
• Ouverture/fermeture
• Substitution de Liskov
• Ségrégation d’interface
• Inversion des dépendances

📐 Formules et lois

Principes SOLID :

• S : Chaque classe doit avoir une responsabilité unique.
• O : Classes ouvertes à l’extension, fermées à la modification.
• L : Les sous-classes doivent remplacer leur classe parente sans erreur.
• I : Préférer plusieurs interfaces spécifiques à une généraliste.
• D : Dépendre d’abstractions plutôt que de classes concrètes.

Règle des trois états d’un objet : Un attribut privé/protégé, accessible via getter/setter, avec encapsulation adaptée.

Sérialisation : Processus d’écrire l’état d’un objet sous forme sérialisée (ex : JSON, XML).

🔍 Méthodes

1. Définir la classe : attributs et méthodes.
2. Choisir la visibilité : public, protégé, privé.
3. Implémenter méthodes spéciales (str, eq, etc.).
4. Formaliser héritage ou interfaces si nécessaire.
5. Garantir le respect des principes SOLID.
6. Modéliser avec UML (classes, séquences).
7. Effectuer des tests unitaires.
8. Documenter avec docstrings.
9. Gérer erreurs via exceptions.
10. Intégrer ou gérer la persistance si besoin.

💡 Exemples

Classe CompteBancaire en Python :

class CompteBancaire:
    def __init__(self, titulaire, solde=0):
        self.titulaire = titulaire
        self._solde = solde  # attribut protégé

    @property
    def solde(self):
        return self._solde

    def deposer(self, montant):
        if montant > 0:
            self._solde += montant

    def retirer(self, montant):
        if 0 < montant <= self._solde:
            self._solde -= montant

Héritage :

class Employe:
    def __init__(self, nom):
        self.nom = nom

class Salarie(Employe):
    def salaire_annuel(self):
        return 30000

Patron Strategy :

from abc import ABC, abstractmethod

class Tarification(ABC):
    @abstractmethod
    def prix(self, montant):
        pass

class PromoPourcentage(Tarification):
    def __init__(self, pourcentage):
        self.pourcentage = pourcentage

    def prix(self, montant):
        return montant * (1 - self.pourcentage / 100)

class Panier:
    def __init__(self, strategie):
        self.strategie = strategie

    def montant_total(self, montant):
        return self.strategie.prix(montant)

⚠️ Pièges

• Confusion entre surcharge et redéfinition : utiliser super() en Python, override en Java.
• Exposer l’état interne d’un objet (favoriser encapsulation).
• Négocier l’usage abusif de l’héritage au lieu de la composition.
• Négliger la gestion cohérente des invariants et exceptions.
• Omettre les tests unitaires et la documentation claire.

📊 Synthèse comparative

Concept	Héritage	Composition
Reutilisation	Reprend tout ou partie de classe	Utilise d’autres classes comme composantes
Flexibilité	Moins flexible (dépendance forte)	Plus flexible (dépendance faible)
Modifications	Impacte la hiérarchie	Modifications locales possible

✅ Checklist examen

• Connaître les principes fondamentaux de la POO.
• Savoir modéliser avec UML.
• Maîtriser la création et gestion d’objets en code.
• Appliquer SOLID dans la conception.
• Différencier héritage et composition.
• Implémenter des méthodes spéciales (str, eq, etc.).
• Gérer erreurs et invariants.
• Utiliser la sérialisation pour la persistance.
• Connaître quelques patrons de conception (Strategy, Factory).