Super et this en Dart

Super et this en Dart

Objectifs du cours

• Comprendre le rôle de super et this dans la programmation orientée objet en Dart.
• Savoir utiliser super pour accéder aux membres de la classe parente.
• Savoir utiliser this pour faire référence à l’objet actuel.
• Appliquer ces concepts dans des exemples pratiques et des exercices.

1. Définitions

1. super

• super : Un mot-clé utilisé pour accéder aux membres (attributs et méthodes) de la classe parente ou de la superclasse.
• Le mot-clé super dans Dart est utilisé pour faire référence aux méthodes ou aux variables de l’objet de classe parent. En termes simples, il est utilisé pour faire référence aux propriétés et méthodes de la superclasse .
• L’utilisation la plus importante du mot-clé super est de supprimer l’ambiguïté entre la superclasse et la sous-classe qui ont des méthodes et des variables portant le même nom.
• Le mot-clé super est capable d’invoquer la méthode et les champs des objets parent, car lorsque nous créons une instance de la sous-classe dans Dart, une instance de la classe parent est également créée implicitement.

1. Accéder à la variable de classe parent

class Animal {
   int count = 150;
}

class Dog extends Animal {
   int count = 70;
   void printNumber(){
    print("Afficher le contenu de la variable locale count: $count");
    print("Afficher le contenu de la variable de la classe Animal count:${super.count}");
   }
}

void main(){
   Dog obj= Dog();
   obj.printNumber();
}
//Output
//Afficher le contenu de la variable locale count: 70
//Afficher le contenu de la variable de la classe Animal count:150

Dans l’exemple ci-dessus, nous avons deux classes Animal et Dog , où Animal est la classe parent (ou Superclass) et Dog est la classe enfant (ou sous-classe). Il convient de noter que la variable nommée count est déclarée à la fois dans la superclasse et la sous-classe, et lorsque nous utilisons super.count elle fera référence à la classe parent (superclasse).

2. Accéder aux méthodes de la classe parent

• En Dart, pour accéder aux méthodes de la classe parent, vous pouvez utiliser le mot-clé super. Le mot-clé super est utilisé pour se référer à la classe parent et accéder à ses propriétés et méthodes.
• Voici comment vous pouvez l’utiliser :

class Parent {
  void maMethode() {
    print("Méthode de la classe parent");
  }
}

class Enfant extends Parent {
  void maMethode() {
    super.maMethode(); // Appel de la méthode de la classe parent
    print("Méthode de la classe enfant");
  }
}

void main() {
  Enfant enfant = new Enfant();
  enfant.maMethode();
}

• Dans cet exemple, la classe Enfant hérite de la classe Parent. Lorsque vous appelez super.maMethode() à l’intérieur de la méthode maMethode() de la classe enfant, cela appelle la méthode maMethode() de la classe parent. Ensuite, le reste du code de la méthode de la classe enfant est exécuté.

2. This

• this : Un mot-clé utilisé pour faire référence à l’objet actuel.
• exemple_this.dart

// exemple_this.dart
// Démonstration complète du mot-clé `this` en Dart
// `this` : référence à l'objet (instance) courant

class CompteBancaire {
  String titulaire;
  double solde;
  static String nomBanque = "Banque Centrale"; // Propriété de classe (pas d'instance)

  // 🔹 1. INITIALISATION RACCOURCIE (Initialising Formals)
  // `this.` devant le paramètre = assignation automatique à la propriété
  CompteBancaire(this.titulaire, [this.solde = 0.0]);

  // 🔹 2. DÉSAMBIGUÏSATION (Paramètre vs Propriété)
  void deposer(double solde) {
    // `this.solde` = propriété de l'objet
    // `solde`     = paramètre de la méthode
    this.solde += solde;
    print("💳 Dépôt de ${solde}€. Solde : ${this.solde}€");
  }

  // 🔹 3. CHAÎNAGE DE MÉTHODES (Method Chaining)
  // Retourner `this` permet d'appeler plusieurs méthodes à la suite
  CompteBancaire retirer(double montant) {
    if (montant <= this.solde) {
      this.solde -= montant;
      print("💸 Retrait de ${montant}€ réussi.");
    } else {
      print("❌ Fond insuffisants pour retirer ${montant}€.");
    }
    return this; // 🌟 Retourne l'instance courante
  }

  // 🔹 4. PASSER L'INSTANCE COURANTE COMME ARGUMENT
  void transfererVers(CompteBancaire destinataire, double montant) {
    if (this.solde >= montant) {
      this.solde -= montant;
      destinataire.solde += montant;
      print("🔄 Transfert de ${montant}€ vers ${destinataire.titulaire}");
    } else {
      print("❌ Transfert impossible : solde insuffisant");
    }
  }

  // 🔹 5. `this` INTERDIT dans un contexte STATIQUE
  static void afficherBanque() {
    // print(this.nomBanque); // ❌ ERREUR DE COMPILATION : `this` n'existe pas ici
    print("🏦 Banque : ${nomBanque}"); // ✅ Accès direct à la propriété static
  }

  // 🔹 6. EXPLICITE vs IMPLICITE
  void afficherInfo() {
    // `this.` est optionnel quand il n'y a pas de conflit de nom
    print("👤 ${titulaire} | 💰 ${solde}€");
    // Equivalent à : print("👤 ${this.titulaire} | 💰 ${this.solde}€");
  }
}

// 🔹 BONUS : Constructeur redirecteur utilisant `this`
class Personne {
  String nom;
  int age;

  Personne(this.nom, this.age);

  // Ce constructeur appelle automatiquement le constructeur principal
  Personne.anonyme() : this("Inconnu", 0);

  void sePresenter() => print("Je suis ${this.nom}, ${this.age} ans.");
}

void main() {
  print("📘 === Exemples d'utilisation de `this` en Dart ===\n");

  // 1️⃣ Initialisation & Désambiguïsation
  print("🔹 1. Initialisation & désambiguïsation");
  var compte1 = CompteBancaire("Alice", 1000.0);
  compte1.deposer(200.0); // Le paramètre `solde` masque la propriété, `this.solde` résout le conflit

  // 2️⃣ Chaînage de méthodes (retour de `this`)
  print("\n🔹 2. Chaînage de méthodes");
  compte1
    .retirer(300)
    .deposer(50)
    .retirer(100);

  // 3️⃣ Passer `this` à une autre instance
  print("\n🔹 3. Transfert entre comptes (`this` comme référence)");
  var compte2 = CompteBancaire("Bob", 500.0);
  compte1.transfererVers(compte2, 150.0);

  // 4️⃣ Contexte statique (`this` interdit)
  print("\n🔹 4. Méthode statique (pas de `this`)");
  CompteBancaire.afficherBanque();

  // 5️⃣ Explicite vs Implicite
  print("\n🔹 5. Accès explicite vs implicite");
  compte1.afficherInfo();

  // 🎁 Bonus : Constructeur redirecteur
  print("\n🎁 Bonus : Constructeur avec `this`");
  var inconnu = Personne.anonyme();
  inconnu.sePresenter();
}

3. Exemple complet

📄 Fichier 1 : parent.dart (Classe de base)

// parent.dart
// Définition de la classe parent avec méthodes et propriétés

class Parent {
  String nom;
  int age;

  // Constructeur de la classe parent
  Parent(this.nom, this.age);

  // Méthode à hériter
  void sePresenter() {
    print("Je suis ${nom}, j'ai ${age} ans. (Parent)");
  }

  // Méthode utilitaire
  String getInfo() {
    return "${nom} - ${age} ans";
  }

  // Méthode virtuelle (à override)
  void action() {
    print("Action générique du parent");
  }
}




📄 Fichier 2 : child.dart (Héritage avec super)

// child.dart
// Classe enfant qui étend Parent et utilise super

import 'parent.dart';

class Enfant extends Parent {
  String ecole;

  // Constructeur : appel obligatoire à super() si Parent n'a pas de constructeur sans paramètre
  Enfant(String nom, int age, this.ecole) : super(nom, age);

  @override
  void sePresenter() {
    // Appel de la méthode parent avec super
    super.sePresenter();
    print("Je suis élève à : ${ecole}");
  }

  @override
  void action() {
    // On enrichit le comportement du parent
    super.action();
    print("L'enfant joue et apprend 🎮📚");
  }

  // Nouvelle méthode utilisant super pour accéder à une propriété parent
  void afficherInfoParent() {
    print("Info depuis parent : ${super.getInfo()}");
  }
}




📄 Fichier 3 : this_example.dart (Usage de this)

// this_example.dart
// Démonstration complète du mot-clé `this`

class Produit {
  String nom;
  double prix;
  static int compteur = 0; // Propriété statique

  // Initialising formals : syntaxe raccourcie avec this
  Produit(this.nom, this.prix) {
    compteur++;
    print("Produit créé : ${this.nom}"); // this optionnel ici car pas d'ambiguïté
  }

  // Méthode avec paramètre portant le même nom qu'une propriété
  void appliquerRemonte(double prix) {
    // this.prix = propriété, prix = paramètre
    this.prix += prix;
    print("Nouveau prix de ${this.nom} : ${this.prix}€");
  }

  // Méthode qui retourne l'instance courante (chaînage)
  Produit appliquerRemise(double pourcentage) {
    this.prix *= (1 - pourcentage / 100);
    return this; // Permet le method chaining
  }

  // Méthode statique : `this` n'est PAS disponible ici ❌
  static void afficherCompteur() {
    // print(this.nom); // ❌ Erreur : this interdit dans un contexte statique
    print("Nombre de produits créés : ${compteur}");
  }
}

// Exemple d'utilisation du chaînage
void demoChaining() {
  var p = Produit("Ordinateur", 1000.0)
    .appliquerRemise(10)   // -10%
    .appliquerRemonte(50); // +50€
  print("Prix final : ${p.prix}€");
}




📄 Fichier 4 : combined_example.dart (this + super ensemble)

// combined_example.dart
// Combinaison avancée de `this` et `super` dans une même classe

import 'parent.dart';

class Employe extends Parent {
  double salaire;
  static const double TAUX_COTISATION = 0.15;

  // Constructeur avec this pour les propriétés de cette classe, super pour le parent
  Employe(String nom, int age, this.salaire) : super(nom, age);

  @override
  void sePresenter() {
    // super : accès au comportement parent
    super.sePresenter();
    // this : accès aux membres de cette instance
    print("${this.nom} gagne ${this.salaire}€/mois");
  }

  // Méthode utilisant à la fois this et super
  double calculerSalaireNet() {
    // this.salaire : propriété locale
    // super.getInfo() : méthode héritée (juste pour l'exemple)
    print("Calcul pour : ${super.getInfo()}");
    return this.salaire * (1 - TAUX_COTISATION);
  }

  // Factory constructor avec validation
  factory Employe.withMinimumSalary(String nom, int age, double salaire) {
    if (salaire < 1500) {
      print("⚠️ Salaire trop bas, ajustement à 1500€");
      salaire = 1500;
    }
    // `this` n'est pas disponible ici (contexte statique du factory)
    return Employe(nom, age, salaire);
  }

  // Méthode de comparaison utilisant this
  bool estPlusAgeQue(Employe autre) {
    return this.age > autre.age; // this.optionnel mais explicite
  }
}




📄 Fichier 5 : main.dart (Point d’entrée et tests)

// main.dart
// Fichier principal pour exécuter tous les exemples

import 'parent.dart';
import 'child.dart';
import 'this_example.dart';
import 'combined_example.dart';

void main() {
  print("🔹 === Exemple 1 : Héritage avec super ===");
  var enfant = Enfant("Léa", 10, "École Primaire");
  enfant.sePresenter();
  enfant.afficherInfoParent();
  enfant.action();

  print("\n🔹 === Exemple 2 : Usage de this ===");
  demoChaining();
  Produit.afficherCompteur();

  print("\n🔹 === Exemple 3 : this + super combinés ===");
  var employe = Employe.withMinimumSalary("Thomas", 35, 1400);
  employe.sePresenter();
  print("Salaire net : ${employe.calculerSalaireNet().toStringAsFixed(2)}€");
  
  var employe2 = Employe("Marie", 28, 2000);
  print("${employe.nom} est plus âgé que ${employe2.nom} ? ${employe.estPlusAgeQue(employe2)}");

  print("\n🔹 === Exemple 4 : Accès explicite à super ===");
  class A {
    String valeur = "Classe A";
    void afficher() => print(valeur);
  }
  class B extends A {
    String valeur = "Classe B";
    void afficher() {
      print(this.valeur);   // "Classe B"
      print(super.valeur);  // "Classe A"
      super.afficher();     // Appel méthode parent
    }
  }
  B().afficher();
}




2. Types d’utilisation

• super est utilisé dans le contexte de l’héritage pour accéder ou modifier les membres de la classe parente.
• this est utilisé pour distinguer les membres d’un objet des paramètres ou des variables locales ayant le même nom.

1. Utilisation de super

1. Activité d’exemple :

• Définissez une classe parente appelée Véhicule avec un attribut vitesseMaximale et une méthode afficherVitesseMaximale() qui affiche la vitesse maximale du véhicule.
• Définissez une classe dérivée appelée Voiture qui hérite de la classe Véhicule. Surchargez la méthode afficherVitesseMaximale() pour afficher également le type de véhicule (voiture).
• Créez une instance de Voiture, appelez la méthode afficherVitesseMaximale() et observez les résultats.

2. Exercice :

• Définissez une classe parente appelée Forme avec un attribut couleur et une méthode afficherCouleur() qui affiche la couleur de la forme.
• Définissez une classe dérivée appelée Cercle qui hérite de la classe Forme. Surchargez la méthode afficherCouleur() pour afficher également le type de forme (cercle).
• Créez une instance de Cercle, appelez la méthode afficherCouleur() et observez les résultats.

2. Utilisation de this

1. Activité d’exemple :

• Définissez une classe Personne avec un attribut nom. Déclarez une méthode afficherNom() qui affiche le nom de la personne.
• Déclarez une autre méthode afficherNomAvecThis() qui utilise this pour afficher le nom de la personne.
• Créez une instance de Personne, appelez les deux méthodes et observez les résultats.

2. Exercice :

• Définissez une classe Produit avec des attributs nom et prix. Déclarez une méthode afficherDetails() qui affiche le nom et le prix du produit.
• Déclarez une autre méthode afficherDetailsAvecThis() qui utilise this pour afficher les détails du produit.
• Créez une instance de Produit, appelez les deux méthodes et observez les résultats.

3. Exercice Pratique : Système de Gestion de Bibliothèque

• Code de départ

// exercice_this_super.dart
// COMPLETER LES TODO SANS MODIFIER LA STRUCTURE EXISTANTE

class Document {
  String titre;
  String auteur;
  bool disponible;

  // TODO 1 : Initialisez les propriétés avec `this` (syntaxe courte Dart)
  Document(String titre, String auteur, [bool disponible = true]) {
    // À compléter
  }

  void emprunter() {
    if (this.disponible) {
      this.disponible = false;
      print("📖 '${this.titre}' est maintenant emprunté.");
    } else {
      print("❌ '${this.titre}' est indisponible.");
    }
  }

  // TODO 2 : Méthode de chaînage. Retournez l'instance courante.
  Document reserver() {
    print("🔖 Réservation de '${this.titre}' confirmée.");
    return ???; // Remplacez ???
  }

  String description() {
    return "'${this.titre}' par ${this.auteur} | ${this.disponible ? '✅ Dispo' : '🔒 Emprunté'}";
  }

  // TODO 3 : Méthode statique. Pourquoi `this` est-il interdit ici ?
  static void afficherRegles() {
    // print(this.titre); // Décommentez pour voir l'erreur
    print("📜 Règle : Emprunt max 14 jours.");
  }
}

class Livre extends Document {
  int nbPages;
  String genre;

  // TODO 4 : Appelez le constructeur parent avec `super`
  Livre(String titre, String auteur, this.nbPages, this.genre)
      : super(???, ???) { // Passez les bons arguments
  }

  @override
  String description() {
    // TODO 5 : Utilisez `super.description()` + infos spécifiques
    return ???;
  }
}

class Magazine extends Document {
  String titre; // ⚠️ Shadowing intentionnel (masque Document.titre)
  int numeroEdition;

  Magazine(String titreDoc, String auteur, this.numeroEdition, this.titre)
      : super(titreDoc, auteur);

  void afficherDoubleTitre() {
    // TODO 6 : Affichez le titre local et le titre parent
    print("📰 Magazine (local) : ${???}");
    print("📄 Document (parent) : ${???}");
  }
}

void main() {
  print("🏛️ === Exercice Bibliothèque ===\n");

  // 1️⃣ Test Document
  var doc = Document("Dart pour tous", "Jean Dupont");
  doc.reserver().emprunter(); // Chaînage

  // 2️⃣ Test Livre (héritage + super)
  var livre = Livre("L'Apprenti Dart", "Marie Code", 320, "Technique");
  print(livre.description());

  // 3️⃣ Test Magazine (shadowing + this/super)
  var mag = Magazine("MagTech", "Éditeur X", 42, "Dart Monthly");
  mag.afficherDoubleTitre();

  // 4️⃣ Test statique
  Document.afficherRegles();
}

• Tâches à réaliser
• Remplacez tous les ??? par le code correct.
• Compilez et exécute





---

Cours Flutter