Classes & Instances

Comprendre le cœur de la POO : la classe (le moule) vs l’instance (l’objet), les constructeurs et la mémoire Stack/Heap.

La Programmation Orientée Objet (POO) est un paradigme qui organise le code autour d’objets du monde réel (ou concepts abstraits) plutôt que de simples suites de fonctions.

Pour maîtriser la POO, la distinction la plus importante à intégrer est la différence entre la Classe et l’Instance (l’Objet).

🪙 L’Analogie Fondamentale : Le Moule et la Pièce

La Classe = Le Moule (Plan)

Une Classe est un modèle abstrait, une recette ou un moule de fabrication.

• Elle ne consomme pas de mémoire pour stocker des données réelles.
• Elle définit la structure (quels attributs existeront) et les capacités (quelles méthodes pourront être exécutées).

# La Classe (Le Moule à Pièces)
class PieceDeMonnaie:
    def __init__(self, valeur, devise):
        self.valeur = valeur    # Attribut
        self.devise = devise    # Attribut

    def afficher(self):         # Méthode
        return f"{self.valeur} {self.devise}"

L’Instance = La Pièce (L’Objet)

Une Instance est un objet concret frappé à partir du moule.

• Elle existe réellement en mémoire (Heap).
• Elle possède sa propre identité et ses propres valeurs pour chaque attribut.

# Instanciation (Fabrication de 2 pièces distinctes)
piece1 = PieceDeMonnaie(1, "EUR")
piece2 = PieceDeMonnaie(2, "EUR")

print(piece1.afficher())  # "1 EUR"
print(piece2.afficher())  # "2 EUR"

⚙️ Usine à Instances Interactive

Créez vos propres objets virtuels en ajustant les paramètres ci-dessous :

Fabrique d’Objets Virtuels

• Nom de l’Objet
• Valeur du Solde
• DeviseEURUSDCHFGBP
• Est Verrouillé

État de l’Instance en Mémoire Heap

Instance ID: #OBJ-\({inp-obj-currency}-042** Classe d'origine: `CompteBancaire` Attribut `.solde`: **\){inp-obj-balance} \({inp-obj-currency}** Attribut `.verrouille`: **\){inp-obj-locked} Statut mémoire: Allocated (Heap RAM)

🧠 La Mémoire : Stack vs Heap

Comprendre où vivent vos variables est essentiel pour éviter les fuites de mémoire et les bugs de référence.

Stack (La Pile d’Exécution)

• Stocke les variables locales d’une fonction et les références (adresses mémoire) vers les objets.
• Gestion ultra-rapide en LIFO (Last In, First Out).
• Taille limitée.

Heap (Le Tas Mémoire)

• Stocke le corps complet des objets et instances créés dynamiquement.
• Taille beaucoup plus grande.
• Géré automatiquement par le Garbage Collector (Ramasse-miettes) en Python/Java/JS.

🔍 Le Piège Classique : Passage par Valeur vs par Référence

• Types Primitifs (Entiers, Booléens) : Copiés par valeur. Modifier la copie ne touche pas à l’original.
• Objets / Instances : Copiés par référence (adresse mémoire). Deux variables pointant vers la même instance modifient le même objet sous-jacent !

🛡️ Les Trois Piliers d’une Instance

L’encapsulation consiste à cacher les détails d’implémentation internes d’un objet et à ne laisser l’extérieur interagir qu’à travers une interface contrôlée (méthodes publiques ou getters/setters).

class CompteSecurise:
    def __init__(self, solde_initial):
        self.__solde = solde_initial  # Attribut privé (masqué)

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

    def get_solde(self):
        return self.__solde

L’héritage permet à une classe enfant d’hériter automatiquement des attributs et méthodes d’une classe parent, tout en pouvant les enrichir ou les redéfinir (override).

class Vehicule:  # Parent
    def rouler(self):
        print("Vroum !")

class VoitureElectrique(Vehicule):  # Enfant
    def recharger(self):
        print("Recharge en cours...")

Le polymorphisme (“plusieurs formes”) permet de traiter des objets d’espèces différentes via une même interface commune sans se soucier de leur classe exacte.

def faire_travailler(employes):
    for emp in employes:
        emp.travailler()  # Chaque sous-classe répond à sa façon !