Introduction à la Programmation Orientée Objet

Qu’est-ce que la POO ?

La programmation orientée objet (POO) est un paradigme qui permet de structurer un programme informatique en modélisant des entités du monde réel sous forme d’objets. Un objet est une entité qui regroupe à la fois des données, appelées attributs, et des comportements, représentés par des méthodes. Par exemple, un objet représentant une « Personne » pourrait contenir un nom et un âge comme attributs, ainsi qu’une méthode permettant à la personne de se présenter.

La POO repose sur plusieurs concepts fondamentaux. Une classe définit le plan de création d’objets. Elle agit comme un moule à partir duquel sont instanciés des objets individuels. Chaque objet est une instance concrète de la classe.

Concept	Description
Encapsulation	Regroupement des données et des méthodes au sein d’une même entité.
Héritage	Capacité d’une classe à hériter des propriétés et méthodes d’une autre.
Polymorphisme	Capacité à utiliser une même interface pour différents types d’objets.
Abstraction	Masquage des détails complexes pour ne montrer que les éléments essentiels.

Pourquoi adopter la POO ?

La programmation orientée objet favorise une organisation du code plus claire et plus modulaire. Chaque classe peut être développée, testée et modifiée indépendamment des autres. Cela améliore la lisibilité du code et facilite la collaboration au sein d’une équipe.

Un autre avantage majeur est la réutilisabilité : une fois qu’une classe est définie, elle peut être utilisée dans plusieurs projets sans devoir être réécrite. La maintenance s’en trouve également simplifiée, car il devient plus facile d’isoler et de corriger des bugs. Enfin, la POO est particulièrement adaptée à la modélisation de systèmes complexes, car elle permet une correspondance naturelle entre les objets du code et les entités réelles qu’ils représentent.

Concepts Détaillés

Définition de Classes et Création d’Objets

Une classe définit la structure et les comportements d’un type d’objet. En Python, on utilise un constructeur spécial appelé __init__ pour initialiser un objet lors de sa création. Par exemple, la classe suivante représente une personne avec un nom et un âge :

class Personne:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age

    def se_presenter(self):
        return f"Bonjour, je m'appelle {self.nom} et j'ai {self.age} ans."

Lorsqu’on crée un objet, ce constructeur est automatiquement appelé. Chaque méthode d’une classe doit inclure le paramètre self, qui fait référence à l’objet courant. Une fois l’objet créé, on peut accéder à ses attributs ou appeler ses méthodes, comme dans l’exemple ci-dessous :

personne1 = Personne("Alice", 30)
print(personne1.nom)
print(personne1.se_presenter())

Variables d’Instance et Variables de Classe

Les variables d’instance sont propres à chaque objet et stockent des informations spécifiques à celui-ci. En revanche, les variables de classe sont partagées entre toutes les instances d’une même classe. Voici un exemple avec une classe Voiture :

class Voiture:
    roues = 4  # Variable de classe

    def __init__(self, marque, modele):
        self.marque = marque
        self.modele = modele

Chaque voiture peut avoir une marque et un modèle différents, mais toutes partagent le même nombre de roues. Il est possible de modifier la variable de classe directement via la classe, ce qui affectera toutes les instances.

Méthodes de Classe et Méthodes Statiques

En POO, il existe différents types de méthodes : les méthodes d’instance, de classe, et les méthodes statiques. Une méthode de classe utilise le décorateur @classmethod et reçoit la classe elle-même en argument, via cls. Elle est utile lorsqu’on souhaite agir sur la classe plutôt que sur une instance.

La méthode statique, définie avec le décorateur @staticmethod, ne dépend ni d’une instance ni de la classe. Elle se comporte comme une fonction utilitaire interne à la classe.

class Utilitaire:
    compteur = 0

    def __init__(self):
        Utilitaire.compteur += 1

    @classmethod
    def nombre_instances(cls):
        return f"{cls.compteur} instances ont été créées."

    @staticmethod
    def afficher_message():
        return "Ceci est une méthode statique."

Encapsulation

L’encapsulation permet de protéger l’état interne d’un objet en limitant l’accès direct à ses données. En Python, on peut définir des attributs privés en les préfixant avec deux tirets bas (__). Ces attributs ne sont pas directement accessibles depuis l’extérieur, ce qui oblige à utiliser des méthodes dédiées pour interagir avec eux.

class CompteBancaire:
    def __init__(self, titulaire, solde):
        self.titulaire = titulaire
        self.__solde = solde

    def deposer(self, montant):
        self.__solde += montant

    def retirer(self, montant):
        if montant > self.__solde:
            return "Fonds insuffisants"
        self.__solde -= montant

    def afficher_solde(self):
        return f"Solde : {self.__solde} €"

Ainsi, on peut sécuriser les opérations sensibles comme le dépôt ou le retrait d’argent, tout en empêchant une modification directe du solde.

Héritage

L’héritage permet de définir une classe en se basant sur une autre. La classe enfant hérite des attributs et méthodes de la classe parente, ce qui permet d’éviter les duplications de code. Il est aussi possible de redéfinir certaines méthodes pour adapter le comportement de la sous-classe.

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

    def parler(self):
        return f"{self.nom} fait un bruit."

class Chien(Animal):
    def parler(self):
        return f"{self.nom} aboie."

class Chat(Animal):
    def parler(self):
        return f"{self.nom} miaule."

Polymorphisme

Grâce au polymorphisme, une même méthode peut être utilisée avec des objets de types différents. Cela permet de traiter plusieurs objets de manière uniforme, à condition qu’ils aient une interface commune.

animaux = [Chien("Rex"), Chat("Luna"), Oiseau()]

for animal in animaux:
    print(animal.parler())

Ici, bien que les objets soient issus de classes différentes, ils partagent tous une méthode parler(), ce qui permet de les manipuler ensemble sans se soucier de leur classe exacte.

Questions

Question 1 : Quel est le principal objectif de la programmation orientée objet ?

L’objectif principal de la programmation orientée objet est de modéliser des entités du monde réel à l’aide d’objets qui regroupent à la fois des données (attributs) et des comportements (méthodes), afin de rendre les programmes plus modulaires, réutilisables et maintenables.

Question 2 : En Python, quel est le rôle de la méthode __init__ dans une classe ?

La méthode __init__ est le constructeur d’une classe. Elle est automatiquement appelée lors de la création d’un objet et sert à initialiser les attributs de celui-ci.

Question 3 : Quelle est la différence entre une variable d’instance et une variable de classe ?

Une variable d’instance est propre à chaque objet, tandis qu’une variable de classe est partagée entre toutes les instances de la classe. Modifier une variable de classe affecte toutes les instances.

Question 4 : Pourquoi l’encapsulation est-elle importante en POO ?

L’encapsulation est importante car elle protège l’état interne d’un objet en limitant l’accès direct à ses données. Cela garantit que les modifications se font uniquement via des méthodes prévues à cet effet, assurant ainsi la sécurité et la cohérence des données.

Question 5 : Quel mot-clé permet de définir une méthode qui agit sur la classe elle-même plutôt que sur une instance ?

Le décorateur @classmethod permet de définir une méthode qui agit sur la classe elle-même, et non sur une instance. Elle reçoit cls comme premier paramètre.

Exercices

Exercice 1 : Écris une classe Python nommée Livre avec deux attributs (titre et auteur) et une méthode decrire() qui renvoie une phrase du type :
« Ce livre s’intitule [titre] et a été écrit par [auteur]. »

class Livre:
    def __init__(self, titre, auteur):
        self.titre = titre
        self.auteur = auteur

    def decrire(self):
        return f"Ce livre s’intitule {self.titre} et a été écrit par {self.auteur}."

Exercice 2 : Modifie la classe Livre pour y ajouter une variable de classe langue = "français" et une méthode de classe changer_langue() qui permet de changer la langue pour tous les livres.

class Livre:
    langue = "français"

    def __init__(self, titre, auteur):
        self.titre = titre
        self.auteur = auteur

    def decrire(self):
        return f"Ce livre s’intitule {self.titre}, écrit par {self.auteur}, en langue {Livre.langue}."

    @classmethod
    def changer_langue(cls, nouvelle_langue):
        cls.langue = nouvelle_langue

Exercice 3 : À partir des classes suivantes, utilise le polymorphisme pour afficher le son de chaque animal sans tester leur type.

class Vache:
    def parler(self):
        return "Meuh"

class Canard:
    def parler(self):
        return "Coin coin"

animaux = [Vache(), Canard()]
for animal in animaux:
    print(animal.parler())

Cela affichera :

Meuh  
Coin coin

La programmation orientée objet

All work licensed under CC BY-NC-SA 4.0