POO Rappels - Aptitek

📚 Cours : Rappels de POO, Typage et UML

🎯 Objectifs de la Section

Comprendre le passage de la programmation procédurale à la POO.
Définir les concepts fondamentaux de la POO (Classe, Objet, Encapsulation, Héritage, Polymorphisme).
Maîtriser les notions de Typage (fort vs. faible) et la distinction entre types primitifs et objets.
Lire et comprendre des diagrammes UML de base.

2.1. 🚀 Introduction : Pourquoi la POO ?

La Programmation Orientée Objet est un paradigme (une manière d’organiser et de structurer le code) qui vise à modéliser le monde réel.

Problème de la Programmation Procédurale : Au fur et à mesure que les projets grandissent, les fonctions et les données sont séparées, rendant le code difficile à maintenir et à faire évoluer.
Solution de la POO : Regrouper les données (attributs) et les actions (méthodes) qui agissent sur ces données au sein d’une seule structure appelée Objet.

Analogie : La programmation procédurale, c’est comme avoir un manuel de cuisine (fonctions) séparé du frigo (données). La POO, c’est avoir des robots-cuiseurs autonomes (objets) qui contiennent à la fois les ingrédients et les recettes.

2.2. 🧱 Les Fondamentaux de la POO

2.2.1. Classe, Type et Objet (Instance)

Concept	Définition	Analogie
Classe (Le Plan)	Le modèle, le plan, la définition d’une structure. Elle n’existe pas concrètement en mémoire lors de l’exécution.	Le plan d’une maison.
Objet (L’Instance)	L’incarnation concrète de la classe en mémoire. On dit que l’on crée une instance de la classe.	La maison réellement construite à l’adresse X.

📐 Illustration UML et Code

En UML, une classe est représentée par un rectangle divisé en trois parties : Nom, Attributs, Méthodes.

$PlantUML Syntax: @startuml !theme sunlust class Voiture {</p> <ul> <li>marque : String</li> <li>vitesse : int</li> </ul> <ul> <li>accelerer(valeur : int) : void } note right: Le signe “-” signifie private\nLe signe “+” signifie public @enduml$

💻 En Java (Mode Notebook) :

// Cellule 1 : Définition de la Classe
class Voiture {
    // Attributs (Données)
    private String marque;
    private int vitesse;

    // Constructeur
    public Voiture(String marque) {
        this.marque = marque;
        this.vitesse = 0;
    }

    // Méthode (Action)
    public void accelerer(int valeur) {
        this.vitesse += valeur;
        System.out.println(this.marque + " roule à " + this.vitesse + " km/h");
    }
}

// Cellule 2 : Création d'instances (Objets)
Voiture v1 = new Voiture("Peugeot"); // Instance 1
Voiture v2 = new Voiture("Ferrari"); // Instance 2

v1.accelerer(50);
v2.accelerer(200);

2.2.2. Les Trois Piliers

Encapsulation 🔒
- Principe : Cacher les détails internes d’un objet. Les attributs sont private et accessibles via des Getters et Setters.
Héritage 🧬
- Principe : Une classe fille hérite des propriétés de la classe mère.
- Relation : “Est-un” (Is-A).
Polymorphisme 🎭
- Principe : Le code peut manipuler des objets de types différents tant qu’ils partagent la même parenté ou interface.

📐 Illustration UML : Héritage

💻 En Java (Mode Notebook) :

// Cellule 1 : Définition de la hiérarchie
class Animal {
    public void crier() { 
        System.out.println("..."); 
    }
}

class Chien extends Animal {
    @Override // Redéfinition (Polymorphisme)
    public void crier() { 
        System.out.println("Wouf !"); 
    }
}

class Chat extends Animal {
    @Override
    public void crier() { 
        System.out.println("Miaou !"); 
    }
}

// Cellule 2 : Utilisation Polymorphique
// On déclare une liste d'Animaux, mais on y met des Chiens et des Chats
import java.util.List;
List
<Animal> zoo = List.of(new Chien(), new Chat());

for (Animal a : zoo) {
    // Le programme décide à l'exécution quelle méthode "crier" appeler
    a.crier(); 
}

2.3. 🔠 Le Concept de Typage

2.3.1. Typage Statique vs. Dynamique et Fort vs. Faible

(Voir tableau section précédente). Java est Statique et Fort.

2.3.2. Types Primitifs vs. Types Objets (Référence)

C’est une distinction cruciale en Java qui cause beaucoup de bugs chez les débutants.

Type	Exemples	Stockage	Copie
Primitifs	`int`, `boolean`, `double`	Pile (Stack)	Copie de la valeur (indépendantes)
Objets	`String`, `Voiture`, `List`	Tas (Heap)	Copie de la référence (adresse)

💻 Démonstration en Java (Mode Notebook) :

// --- Cas 1 : Primitifs (Par valeur) ---
int a = 10;
int b = a; // b vaut 10
b = 20;    // On change b

System.out.println("A: " + a); // A reste 10 ! (Indépendance)
System.out.println("B: " + b); // B vaut 20

// --- Cas 2 : Objets (Par référence) ---
// Imaginons une classe simple 'Boite' qui contient un nombre
class Boite { int valeur = 10; }

Boite b1 = new Boite();
Boite b2 = b1; // ATTENTION : b2 pointe vers la MÊME boite que b1

b2.valeur = 99; // On modifie via b2

System.out.println("B1: " + b1.valeur); // B1 affiche 99 ! (Liaison)

2.4. 🛠️ Mise en Pratique : Classes Abstraites et Interfaces

2.4.1. L’Interface (Le Contrat)

C’est le pivot des principes SOLID. Elle définit ce que l’objet peut faire, sans dire comment.

📐 Illustration UML : L’implémentation

En UML, l’implémentation d’une interface est représentée par une flèche en pointillés.

2.5. 📐 Rappel : Le Langage UML (Unified Modeling Language)

L’UML est un langage visuel standardisé pour spécifier, visualiser et documenter les systèmes logiciels. Il n’est pas lié à Java, mais s’y applique parfaitement.

2.5.1. Les Diagrammes Principaux

Diagramme de Classes (Statique) : Montre la structure du système, les attributs et les relations. C’est celui que nous utilisons le plus pour le code.
Diagramme de Séquence (Dynamique) : Montre les interactions entre objets au fil du temps (Qui appelle quoi et quand).

2.5.2. Les Relations Clés en PlantUML

Voici un résumé visuel des flèches que vous croiserez souvent :

Relation	Signification en Code	Syntaxe PlantUML
Héritage	`extends`	`Mère <
Implémentation	`implements`	`Interface <
Association	A connaît B (champ)	`A --> B`
Composition	A “possède” B (B meurt si A meurt)	`A *-- B`