4.0 LE CONSTRUCTEUR – Initialisation des Objets

Définition détaillée : Le constructeur est une méthode spéciale d’une classe (en Python, __init__) qui est appelée automatiquement lors de la création d’un nouvel objet. Il permet d’initialiser les attributs de l’objet avec des valeurs de départ, garantissant que chaque instance commence dans un état cohérent.

Exemple dans le projet :

class Robot:
    def __init__(self, nom: str, energie: float = 100.0):
        self._nom = nom
        self._energie = energie
        self._etat = "prêt"

Le constructeur __init__ initialise ici le nom, l’énergie et l’état du robot dès sa création.

4.1 ENCAPSULATION – Protection et Contrôle

Définition détaillée : L’encapsulation est le principe qui consiste à regrouper les données (attributs) et les méthodes qui manipulent ces données au sein d’une même entité (la classe). Elle protège l’état interne de l’objet en rendant certains attributs privés (préfixe _ ou __), accessibles uniquement via des méthodes publiques appelées accesseurs (getters) et mutateurs (setters). Cela permet de contrôler la modification des données et d’éviter les incohérences.

Exemple dans le projet :

class Capteur(ABC):
    def __init__(self, id_capteur: str, type_capteur: str):
        self._id = id_capteur.strip()      # Attribut privé
        self._type = type_capteur.strip()  # Attribut privé
        self._valeur = 0.0                 # Attribut privé

    def get_valeur(self) -> float:
        return self._valeur

    def set_valeur(self, v: float):
        if v >= 0:
            self._valeur = v
        else:
            raise ValueError("Valeur invalide")

Ici, les attributs sont protégés et l’accès se fait via des méthodes dédiées, garantissant la cohérence des valeurs.

4.2 HÉRITAGE – Réutilisation et Spécialisation

Définition détaillée : L’héritage permet de créer une nouvelle classe (dite « fille » ou « dérivée ») à partir d’une classe existante (dite « mère » ou « de base »). La classe fille hérite des attributs et méthodes de la classe mère, ce qui favorise la réutilisation du code et la spécialisation. Elle peut aussi redéfinir ou étendre certains comportements.

Exemple dans le projet :

class Robot(ABC):
    # Classe abstraite de base

class RobotMobile(Robot):
    def __init__(self, nom: str, vitesse: float):
        super().__init__(nom)  # Appel du constructeur parent
        self._vitesse_max = float(vitesse)

La classe RobotMobile hérite de Robot et ajoute des fonctionnalités spécifiques liées à la mobilité.

4.3 POLYMORPHISME – Flexibilité et Extensibilité

Définition détaillée : Le polymorphisme permet d’utiliser la même interface (méthode ou attribut) pour des objets de types différents. Chaque sous-classe peut redéfinir la méthode héritée pour adapter son comportement. Ainsi, le même appel de méthode peut produire des effets différents selon l’objet ciblé.

Exemple dans le projet :

class Capteur(ABC):
    @abstractmethod
    def lire_valeur(self):
        pass

class Camera(Capteur):
    def lire_valeur(self):
        # Spécifique à la caméra

class Gyroscope(Capteur):
    def lire_valeur(self):
        # Spécifique au gyroscope

# Utilisation polymorphique
capteurs = [Camera(...), Gyroscope(...)]
for capteur in capteurs:
    capteur.lire_valeur()  # Appelle la méthode adaptée à chaque type

La même méthode (lire_valeur) est appelée sur chaque objet, mais le comportement dépend de la sous-classe concrète.

4.4 ABSTRACTION – Simplification et Modularité

Définition détaillée : L’abstraction consiste à définir des classes ou méthodes sans implémentation concrète (classes ou méthodes abstraites). Elle impose un contrat aux sous-classes, qui devront fournir leur propre implémentation. Cela permet de structurer le code et de clarifier les responsabilités de chaque classe.

Exemple dans le projet :

from abc import ABC, abstractmethod

class Robot(ABC):
    @abstractmethod
    def move(self):
        pass  # Doit être redéfinie dans les sous-classes

La classe Robot impose la présence de la méthode move() dans ses sous-classes, sans en donner le détail.

4.5 COMPOSITION & AGRÉGATION – Construction d’objets complexes

Définition détaillée : La composition et l’agrégation sont des relations qui permettent de construire des objets complexes à partir d’autres objets. La composition implique que l’objet composé possède et gère le cycle de vie de ses composants ; l’agrégation indique une relation plus souple, où les objets peuvent exister indépendamment.

Exemple dans le projet :

class ActionSystem:
    def __init__(self):
        self._actionneurs: Dict[str, Actionneur] = {}
        self._moteurs: List[Moteur] = []
        self._bras_robotiques: List[BrasRobotique] = []

La classe ActionSystem est composée d’objets Moteur, BrasRobotique et Actionneur : elle orchestre leur fonctionnement. De même, RobotMobile possède des sous-systèmes comme GestionnaireStockage ou IA (composition/agrégation).

6.1 Diagramme de Classes Principal (avec packages)

Définition : Le diagramme de classes UML représente la structure statique du système : il montre les classes, leurs attributs, méthodes, ainsi que les relations (héritage, composition, agrégation, associations) entre elles. Il permet de visualiser l’architecture orientée objet et la répartition des responsabilités.

Objectif : Offrir une vue d’ensemble de l’architecture logicielle, faciliter la compréhension des interactions entre modules et guider l’implémentation du code.

Points clés illustrés :

• Héritage : Robot → RobotMobile, BrasRobotique
• Composition : Robot contient PerceptionSystem, ActionSystem
• Agrégation : Robot utilise Navigation, GestionnaireStockage
• Polymorphisme : Méthodes virtuelles redéfinies
• Encapsulation : Attributs privés + méthodes publiques

6.2 Diagramme de Classes (sans packages)

Définition : Ce diagramme de classes simplifié présente uniquement les classes principales et leurs relations, sans la structure de packages, pour une lecture plus directe des liens POO.

Objectif : Permettre une compréhension rapide des relations d’héritage, de composition et d’agrégation entre les classes majeures du projet.