Objets et classes : le modèle de la POO

Qu'est-ce que la programmation orientée objet (POO) ?

La programmation orientée objet (POO) est un paradigme de programmation qui repose sur le concept d'"objets". Un objet est une entité qui combine des données (appelées attributs) et des actions (appelées méthodes).

La POO permet de modéliser des problèmes du monde réel de manière plus intuitive, en représentant les entités du problème comme des objets qui interagissent entre eux.

Imaginez que vous voulez modéliser un chat. En POO, vous créeriez un objet "chat" qui aurait des attributs comme `nom`, `age`, `couleur`, et des méthodes comme `miauler`, `manger`, `dormir`.

La POO favorise la modularité, la réutilisabilité et la maintenabilité du code.

Objets : instances de classes

Un objet est une *instance* d'une classe. La classe est le "plan" ou le "modèle" à partir duquel les objets sont créés.

Par exemple, si vous avez une classe `Chat`, vous pouvez créer plusieurs objets `Chat`, chacun représentant un chat spécifique avec ses propres attributs (nom, age, couleur différents).

Chaque objet a sa propre identité, son propre état (les valeurs de ses attributs), et son propre comportement (ses méthodes).

En Python, presque tout est un objet : les nombres, les chaînes de caractères, les listes, les fonctions, etc. Même les classes sont des objets (des instances de la métaclasse `type`).

Classes : plans de construction pour les objets

Une classe est un modèle ou un plan de construction pour créer des objets. Elle définit les attributs (les données) et les méthodes (les actions) que les objets de cette classe auront.

La classe définit *ce que* les objets seront et *ce qu'ils pourront faire*, mais elle ne crée pas d'objets directement. Pour créer un objet, vous devez *instancier* la classe.

Pensez à une classe comme à un moule à gâteau. Le moule (la classe) définit la forme du gâteau, mais il ne crée pas le gâteau lui-même. Pour avoir un gâteau, vous devez utiliser le moule (instancier la classe).

En Python, vous définissez une classe en utilisant le mot-clé `class`.

Exemple simple : modéliser un cercle

Voici un exemple simple de classe Python qui modélise un cercle :

class Cercle:
    """Représente un cercle dans le plan."""

    def __init__(self, rayon):
        """Initialise un cercle avec un rayon donné."""
        self.rayon = rayon

    def aire(self):
        """Calcule l'aire du cercle."""
        return 3.14159 * self.rayon * self.rayon

    def perimetre(self):
        """Calcule le périmètre du cercle."""
        return 2 * 3.14159 * self.rayon

# Création d'objets (instances) de la classe Cercle
c1 = Cercle(5)  # Crée un cercle de rayon 5
c2 = Cercle(10) # Crée un cercle de rayon 10

# Accès aux attributs
print(c1.rayon)  # Affiche 5
print(c2.rayon)  # Affiche 10

# Appel des méthodes
print(c1.aire())      # Affiche 78.53975 (environ)
print(c2.perimetre()) # Affiche 62.8318 (environ)

Dans cet exemple :

• `Cercle` est une classe qui définit le modèle pour les objets "cercle".
• `__init__` est une méthode spéciale appelée constructeur. Elle est appelée automatiquement lorsque vous créez un nouvel objet de la classe. Elle permet d'initialiser les attributs de l'objet. Le paramètre `self` fait référence à l'objet lui-même (voir section suivante).
• `rayon` est un attribut. Chaque objet `Cercle` aura son propre attribut `rayon`.
• `aire` et `perimetre` sont des méthodes. Elles définissent les actions que les objets `Cercle` peuvent effectuer.
• `c1` et `c2` sont des objets (des instances) de la classe `Cercle`.

Le paramètre self : référence à l'objet courant

Le paramètre `self` est une convention en Python (vous pourriez techniquement utiliser un autre nom, mais c'est fortement déconseillé). Il représente l'objet sur lequel la méthode est appelée.

Lorsque vous appelez une méthode sur un objet (par exemple, `c1.aire()`), Python passe automatiquement l'objet lui-même (`c1` dans ce cas) comme premier argument de la méthode. C'est pourquoi les méthodes ont (presque) toujours `self` comme premier paramètre.

A l'intérieur de la méthode, vous utilisez `self` pour accéder aux attributs et aux autres méthodes de l'objet.

Dans l'exemple de la classe `Cercle`, `self.rayon` fait référence à l'attribut `rayon` de l'objet sur lequel la méthode est appelée (par exemple, `c1.rayon` ou `c2.rayon`).

Le constructeur `__init__` utilise également `self` pour initialiser les attributs de l'objet lors de sa création.