Module Dart.7 – Programmation Orientée Objet

Objectif

Maîtriser la POO complète en Dart : classes, constructeurs, héritage, interfaces, mixins pour créer des architectures modulaires et maintenables.

Théorie

Classes

Définition

class Personne {
    // Propriétés
    String nom;
    int age;
    
    // Constructeur
    Personne(this.nom, this.age);
    
    // Méthodes
    void saluer() {
        print('Bonjour $nom');
    }
}

Création d'objets

var jean = Personne('Jean', 30);
jean.saluer();

Constructeurs

Constructeur par défaut

Si aucun constructeur n'est défini, Dart en crée un par défaut.

class Personne {
    String nom = '';
    // Constructeur par défaut implicite
}

var p = Personne();  // OK

Constructeur avec initialisation

Syntaxe concise Dart.

class Personne {
    String nom;
    int age;
    
    Personne(this.nom, this.age);
}

Constructeurs nommés

Plusieurs constructeurs avec des noms différents.

class Personne {
    String nom;
    int age;
    
    Personne(this.nom, this.age);
    
    Personne.anonyme() {
        nom = 'Anonyme';
        age = 0;
    }
    
    Personne.parDefaut() : nom = 'Inconnu', age = 0;
}

var p1 = Personne('Jean', 30);
var p2 = Personne.anonyme();
var p3 = Personne.parDefaut();

Initialisation list

Exécute du code avant le corps du constructeur.

class Personne {
    String nom;
    int age;
    String description;
    
    Personne(this.nom, this.age) : description = '${nom} a $age ans' {
        print('Personne créée');
    }
}

Encapsulation

Visibilité

Dart n'a pas de mots-clés public/private comme Java. Par convention :

• Début par _ = privé (même fichier)
• Sans _ = public

class Personne {
    String nom;        // Public
    int _age;          // Privé (accessible seulement dans ce fichier)
    
    int get age => _age;
    void set age(int value) {
        if (value > 0) {
            _age = value;
        }
    }
}

Getters et Setters

class Personne {
    int _age = 0;
    
    int get age => _age;
    
    set age(int value) {
        if (value > 0 && value < 150) {
            _age = value;
        }
    }
}

Héritage

Une classe peut hériter d'une autre classe.

Syntaxe

class Etudiant extends Personne {
    String ecole;
    
    Etudiant(String nom, int age, this.ecole) : super(nom, age);
    
    @override
    void saluer() {
        super.saluer();  // Appelle la méthode parente
        print('École : $ecole');
    }
}

super

Référence à la classe parente.

class Etudiant extends Personne {
    Etudiant(String nom, int age, String ecole) : super(nom, age) {
        this.ecole = ecole;
    }
}

@override

Annotation indiquant qu'on redéfinit une méthode parente.

@override
void saluer() {
    // Redéfinition
}

Interfaces

En Dart, toute classe est implicitement une interface.

Implémentation explicite

abstract class Affichable {
    void afficher();
}

class Personne implements Affichable {
    @override
    void afficher() {
        print('Personne');
    }
}

Plusieurs interfaces

abstract class Affichable {
    void afficher();
}

abstract class Sauvegardable {
    void sauvegarder();
}

class Personne implements Affichable, Sauvegardable {
    @override
    void afficher() {
        // Implémentation
    }
    
    @override
    void sauvegarder() {
        // Implémentation
    }
}

Abstraction

Classes abstraites

Ne peut pas être instanciée, sert de base.

abstract class Animal {
    String nom;
    
    Animal(this.nom);
    
    // Méthode concrète
    void dormir() {
        print('$nom dort');
    }
    
    // Méthode abstraite (doit être implémentée)
    void faireDuBruit();
}

class Chien extends Animal {
    Chien(String nom) : super(nom);
    
    @override
    void faireDuBruit() {
        print('Wouf !');
    }
}

Mixins

Permettent de réutiliser du code entre classes sans héritage.

Définition

mixin Loggable {
    void log(String message) {
        print('Log: $message');
    }
}

mixin Sauvegardable {
    void sauvegarder() {
        print('Sauvegardé');
    }
}

Utilisation

class Personne with Loggable {
    String nom;
    
    Personne(this.nom);
    
    void creer() {
        log('Personne $nom créée');
    }
}

class Etudiant extends Personne with Loggable, Sauvegardable {
    Etudiant(String nom) : super(nom);
}

Restrictions (on)

Limiter un mixin à certaines classes.

mixin Loggable on Personne {
    void log(String message) {
        print('Log: $message');
    }
}

class Personne {
    String nom;
}

class Etudiant extends Personne with Loggable {
    // OK : Etudiant extends Personne
}

Polymorphisme

Traiter différents types de manière uniforme.

List<Animal> animaux = [
    Chien('Rex'),
    Chat('Mimi')
];

for (Animal animal in animaux) {
    animal.faireDuBruit();  // Polymorphisme
}

Exercice

1. Classes

   • Créez des classes avec constructeurs
   • Testez l'encapsulation avec _
   • Utilisez getters/setters

2. Héritage

   • Créez une hiérarchie de classes
   • Testez super et @override
   • Comprenez le polymorphisme

3. Interfaces

   • Créez des classes abstraites
   • Implémentez-les dans des classes
   • Testez l'implémentation multiple

4. Mixins

   • Créez des mixins réutilisables
   • Utilisez-les dans plusieurs classes
   • Testez les restrictions on

5. POO complète

   • Créez un système avec tous les concepts
   • Utilisez héritage, interfaces, mixins
   • Testez le polymorphisme

Quiz

1. Comment rendre une propriété privée en Dart ?

   • private
   • Commencer par _ (underscore)
   • protected

2. Que fait super() ?

   • Crée un super objet
   • Appelle le constructeur parent
   • Appelle une méthode parente

3. Quelle est la différence entre extends et implements ?

   • Aucune différence
   • extends = héritage, implements = interface
   • implements est plus rapide

4. Que sont les mixins ?

   • Des classes
   • Du code réutilisable sans héritage
   • Des interfaces

5. Que signifie @override ?

   • Crée une nouvelle méthode
   • Redéfinit une méthode parente
   • Supprime la méthode parente

Mini défi

Mission : Créer un système POO complet

Créez un système de gestion de bibliothèque :

Structure :

1. Interface Empruntable (emprunter, retourner, estDisponible)
2. Classe abstraite Document (titre, auteur)
3. Classe Livre (hérite Document, implémente Empruntable)
4. Classe DVD (hérite Document, implémente Empruntable)
5. Mixin Loggable (log des actions)
6. Classe Bibliotheque (gère collection de Documents)

Critères :

• ✅ POO complète (héritage, interfaces, mixins)
• ✅ Encapsulation appropriée
• ✅ Polymorphisme utilisé
• ✅ Code bien structuré

Objectif : Maîtriser la POO complète Dart et créer une architecture propre.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez classes, héritage, interfaces, mixins et polymorphisme.