✨ Principes Généraux de Qualité de Code et Architectures

Cette section présente les bonnes pratiques et les structures de base pour organiser le code de manière maintenable.

3.1. Les Principes de Simplicité et d’Efficacité

• DRY (Don’t Repeat Yourself) 🚫

  • Principe : Chaque connaissance ou fonctionnalité doit avoir une représentation unique.

  • Application en POO : Utiliser l’Héritage et les Méthodes pour factoriser le code.

💻 Exemple Interactif (Comparaison) :

// ❌ Code qui viole le DRY (Répétition)
String u1 = "Alice";
System.out.println("--- FICHE UTILISATEUR ---");
System.out.println("Nom : " + u1);

String u2 = "Bob";
System.out.println("--- FICHE UTILISATEUR ---");
System.out.println("Nom : " + u2);

// ✅ Code DRY (Factorisé)
void afficherFiche(String nom) {
    System.out.println("--- FICHE UTILISATEUR ---");
    System.out.println("Nom : " + nom);
}

afficherFiche("Alice");
afficherFiche("Bob");

• YAGNI (You Ain’t Gonna Need It) 🤷

  • Principe : Ne pas ajouter de fonctionnalités si elles ne sont pas nécessaires immédiatement.

  • Objectif : Éviter la sur-ingénierie.

• TDM (Tout Dans le Main) 💥

  • Principe à Éviter : Mettre toute la logique dans main.

  • Conséquence : Monolithe illisible et impossible à tester.

---

3.2. Le Principe d’API et de Contrat

• Définition d’API : Un contrat définissant comment un composant peut être utilisé.

• Lien avec la POO : Une Interface formalise ce contrat.

📐 Illustration UML : Le Contrat

---

3.3. Modèles d’Architecture et de Conception

3.3.1. CRUD (Create, Read, Update, Delete)

Les 4 opérations fondamentales de la persistance des données.

💻 Exemple d’Interface CRUD générique :

interface Repository
<T> {
    void create(T data);    // C
    T read(int id);         // R
    void update(T data);    // U
    void delete(int id);    // D
}

3.3.2. Le Patron de Conception : MVC (Model-View-Controller)

Le MVC sépare les responsabilités de l’interface utilisateur.

Composant	Rôle
Modèle (M)	Données et Logique Métier (L’état).
Vue (V)	Affichage (HTML, Console).
Contrôleur (C)	Chef d’orchestre (Reçoit l’action -> Modifie le Modèle -> Met à jour la Vue).

📐 Diagramme de Séquence UML (Flux d’exécution) :

Extrait de code

💻 Implémentation Complète en Mode Notebook :

Copiez ces blocs dans des cellules séparées pour tester le MVC.

// 1. LE MODÈLE (La donnée brute)
class Etudiant {
    private String nom;
    public Etudiant(String nom) { this.nom = nom; }
    public String getNom() { return nom; }
    public void setNom(String nom) { this.nom = nom; }
}

// 2. LA VUE (L'affichage bête et méchant)
class EtudiantView {
    public void afficherDetails(String nomEtudiant) {
        System.out.println("🖥️ AFFICHAGE VUE : Étudiant = " + nomEtudiant);
    }
}

// 3. LE CONTRÔLEUR (Le chef d'orchestre)
class EtudiantController {
    private Etudiant modele;
    private EtudiantView vue;

    public EtudiantController(Etudiant modele, EtudiantView vue) {
        this.modele = modele;
        this.vue = vue;
    }

    public void mettreAJourNom(String nom) {
        this.modele.setNom(nom);
    }

    public void updateVue() {
        // Le contrôleur tire les données du modèle et les pousse dans la vue
        this.vue.afficherDetails(modele.getNom());
    }
}

// 4. EXÉCUTION (Simulation de l'App)
Etudiant model = new Etudiant("Jean");
EtudiantView view = new EtudiantView();
EtudiantController controller = new EtudiantController(model, view);

// État initial
controller.updateVue();

// L'utilisateur change le nom via le contrôleur
controller.mettreAJourNom("Jean-Pierre");
controller.updateVue();

3.3.3. Le Modèle d’Architecture : 3-Tiers (ou en Couches)

Architecture organisant le système à grande échelle (souvent physique).

📐 Diagramme de Composants UML :

---

3.4. ❓ Différence Clé : MVC vs. Modèle 3-Tiers

Caractéristique	MVC	Modèle 3-Tiers
Type	Patron de Conception (Code interne).	Modèle Architectural (Structure du système).
Portée	Focus sur l’UI.	Focus sur l’Infrastructure.
Relation	Le MVC vit souvent dans la Couche de Présentation.

En résumé : Le 3-Tiers est l’étagère (structure) ; le MVC est la façon dont vous rangez les livres (code) sur l’étagère du haut.