Introduction à la Programmation Orientée Objet

Synthèse rapide

La Programmation Orientée Objet (POO) permet une modélisation du monde réel via des classes et des objets.

Les principaux concepts sont : classes, objets, encapsulation, héritage, polymorphisme et abstraction.

La conception de code orienté objet doit suivre le principe SOLID, garantissant lisibilité et maintenabilité.

La modélisation UML de base utilise notamment les diagrammes de classes et de séquences.

La POO favorise la réutilisation, la testabilité et la structuration claire d’un projet.

Les patrons de conception comme Strategy, Observer et Factory sont couramment utilisés pour résoudre des problèmes récurrents.

La gestion d’erreurs doit être soigneusement pensée via exceptions et invariants.

Les méthodes spéciales permettent de définir le comportement d’objets (surcharge d’str, eq, etc.).

La persistance peut s’appuyer sur la sérialisation (JSON, databasing léger) pour sécuriser et restaurer l’état.

La conception doit intégrer l’inversion de dépendances et une architecture modulaire (Ports & Adapters).

Concepts et définitions

Classe : modèle ou plan de construction d’un objet.

Objet : instance d’une classe, représentant une entité concrète.

Encapsulation : principe consistant à protéger l’état interne d’un objet.

Héritage : mécanisme permettant de créer une nouvelle classe à partir d’une classe existante.

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

Abstraction : définition d’une interface ou d’un contrat sans implémentation concrète.

Patrons de conception : solutions réutilisables à des problématiques communes en programmation orientée objet.

SOLID : principes fondamentaux pour un design OO robuste : Responsabilité unique, Ouverture/fermeture, Substitution de Liskov, Ségrégation d’interface, Inversion des dépendances.

Formules, lois, principes

Principes SOLID :

S : Responsabilité unique — chaque classe doit avoir une seule responsabilité.
O : Ouvert/fermé — classes ouvertes à l’extension mais fermées à la modification.
L : Substitution de Liskov — sous-classes doivent pouvoir remplacer leur classe parente sans erreur.
I : Ségrégation d’interface — préférez plusieurs interfaces spécifiques à une interface commune.
D : Inversion de dépendance — dépendance à des abstractions plutôt qu’à des concrètes.

Règle des trois états d’un objet : attribut privé protégé, getter/setter en Python, visibilité en Java/C#.

Sérialisation : écriture/d développement de l’état d’un objet sous forme sérialisée (JSON, XML).

Méthodes et procédures

Définir la classe avec ses attributs et méthodes.

Choisir la visibilité : public, protégé, privé.

Implémenter les méthodes spéciales (str, repr, eq, etc.).

Formaliser l’héritage ou l’interface si nécessaire.

Respecter le principe SOLID lors de la conception.

Utiliser UML pour modéliser la structure du système.

Effectuer des tests unitaires pour chaque composant.

Documenter avec des docstrings et des commentaires.

Gérer les erreurs via des exceptions adaptées.

Intégrer la persistance si besoin (sérialisation, base de données).

Exemples illustratifs

Classe CompteBancaire en Python :

Attributs : titulaire, solde (protégé _solde).
Méthodes : deposer(montant), retirer(montant), solde().
Sécurisation du solde avec propriété en lecture seule.

Héritage :

Classe Employe, sous-classes Salarie et Freelance, avec des méthodes spécifiques.

Patron Strategy :

Interface Tarification avec méthode prix().
Implémentations : PromoPourcentage, fixe.
Utilisation dans une classe Panier pour calculer le montant à payer selon la stratégie choisie.

Pièges et points d'attention

Confondre surcharge et redéfinition (super() en Python, override en Java).

Exposer trop facilement l’état interne, favorisant la mutabilité.

Négliger le principe de Responsabilité Unique dans le design.

Mal gérer les invariants ou les exceptions, ce qui peut mener à des états incohérents.

Utiliser l’héritage de façon abusive au lieu de composition.

Ignorer l’importance des tests unitaires et de la documentation.

Glossaire

Classe : Modèle de données et comportements.

Objet : Instance concrète d’une classe.

Encapsulation : Protection des données internes.

Héritage : Extending une classe.

Polymorphisme : Méthodes identiques avec comportements différenciés.

Abstraction : Contrat ou interface sans implémentation.

Patron de conception : Solution réutilisable pour un problème récurrent.

SOLID : Principes pour un code maintenable et évolutif.

Union type : type indiquant qu’une variable peut être de plusieurs types (en Python, avec typing).

📌 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

Définir la classe : attributs et méthodes.
Choisir la visibilité : public, protégé, privé.
Implémenter méthodes spéciales (str, eq, etc.).
Formaliser héritage ou interfaces si nécessaire.
Garantir le respect des principes SOLID.
Modéliser avec UML (classes, séquences).
Effectuer des tests unitaires.
Documenter avec docstrings.
Gérer erreurs via exceptions.
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).

Introduction à la Programmation Orientée Objet

Crée tes propres fiches en 30 secondes

Synthèse rapide

Concepts et définitions

Formules, lois, principes

Méthodes et procédures

Exemples illustratifs

Pièges et points d'attention

Glossaire

Introduction à la Programmation Orientée Objet

Crée tes propres fiches en 30 secondes

📌 L'essentiel

📖 Concepts clés

📐 Formules et lois

🔍 Méthodes

💡 Exemples

⚠️ Pièges

📊 Synthèse comparative

✅ Checklist examen

Introduction à la Programmation Orientée Objet

Introduction à la Programmation Orientée Objet

Quel concept permet de créer un nouveau type basé sur une classe existante en programmation orientée objet ?

Introduction à la Programmation Orientée Objet

Progression globale

Détail par thème

Introduction au système

Les différents types

Structure axiale

Structure appendiculaire

Suivi de progression par thème