Les constructeurs de classe dans Dart

Présentation

• Le constructeur est une méthode spéciale utilisée pour initialiser un objet lorsqu'il est créé dans le programme.
• En programmation orientée objet, lorsqu'un objet est créé, il appelle automatiquement le constructeur.
• Toutes les classes ont leur constructeur par défaut qui est créé par le compilateur lorsque la classe est appelée, de plus on peut également définir son propre constructeur.
• L'instanciation d'un objet se fait par l'appel à un constructeur. La syntaxe est la même qu'en Java.
• Le constructeur et les autres méthodes de classe présentent plusieurs différences significatives.
  • Le constructeur porte le même nom que le nom de la classe.
  • Le constructeur n'a pas de type de retour.
  • Lorsqu'un objet est créé, le constructeur est automatiquement appelé.
  • Si aucun constructeur n'est spécifié, le constructeur sans argument par défaut est utilisé.
• Par exemple, si on a un attribut "nom" dans notre classe, le paramètre devra être "this.nom". Il n'y a alors pas besoin d' écrire le corps de la méthode.

Syntaxe et utilisation

• Les constructeurs ont le même nom que le nom de la classe et n'ont pas de type de retour.
• Dans la syntaxe ci-dessus :

class_name( [ paramètres ] ){
    // Corps du constructeur
}

• class_name est le nom de la classe dont le constructeur est créé.
• les paramètres sont des fonctionnalités facultatives et ils peuvent et ne peuvent pas être définis pour le constructeur. Le constructeur par défaut ne contient aucun paramètre défini.
• Le corps du constructeur est le corps du constructeur et est exécuté lorsque le constructeur est appelé, c'est-à-dire lorsqu'un objet est créé.

Les constructeurs n'ont pas de type de retour.

Créer un constructeur dans Dart

Tout d'abord, voyons comment écrire un constructeur de base dans dart.

Comme nous l'avons mentionné, un constructeur a le même nom que son nom de classe et il ne renvoie aucune valeur.

Supposons que si nous avons la classe Etudiant, le nom du constructeur doit également être Etudiant.

Dans l'exemple ci-contre, nous avons créé une fonction constructeur Etudiant() qui est identique au nom de la classe. Nous avons passé deux paramètres dans le constructeur et lorsque nous avons instancié un objet de la classe Etudiant, il a automatiquement appeler le constructeur puis afficher le résultat.

void main() {
  // Création d'un objet
  Etudiant std = new Etudiant("Ahmed", 26);
}
class Etudiant {
  // Déclarer un construstor
  Etudiant(String str, int age) {
    print("Le nom est: ${str}");
    print("L'âge est: ${age}");
  }
}

Types de constructeurs dans Dart

• Il existe plusieurs types de constructeurs dans Dart, que vous pouvez utiliser pour initialiser une classe. Voici une liste des principaux types de constructeurs en Dart :

  1. Constructeur par défaut

     • Dart crée automatiquement un constructeur par défaut si vous n'en définissez pas explicitement un. Ce constructeur par défaut initialise les propriétés à leurs valeurs par défaut (0 pour les types numériques, null pour les types objet, etc.).

     • Syntaxe

       class MyClass {
         // Propriétés de la classe
         // ...
       
         // Constructeur par défaut (implicitement fourni par Dart)
         // Vous n'avez pas besoin de le déclarer explicitement
       }

     • Le constructeur par défaut est un constructeur qui n'a aucun paramètre.
     • Si vous ne déclarez pas de constructeur, un constructeur par défaut vous est fourni. Le constructeur par défaut n'a pas d'arguments et appelle le constructeur sans argument dans la superclasse (vous le comprendrez mieux dans la leçon sur le super constructeur).

     • Exemple

       class Person {
         String name;
         int age;
       
         // Le constructeur par défaut est implicitement fourni par Dart
       }
       
       void main() {
         // Création d'une instance de Person en utilisant le constructeur par défaut
         Person person = Person();
       
         // Accéder aux propriétés de l'objet
         person.name = "Alice";
         person.age = 30;
       
         // Affichage des détails
         print("Name: ${person.name}, Age: ${person.age}");
       }

     • Dans cet exemple, la classe Person a deux propriétés : name et age. Comme aucun constructeur n'est défini, Dart fournit automatiquement un constructeur par défaut qui initialise name à null et age à 0. Ensuite, dans la fonction main(), nous créons une instance de Person en utilisant le constructeur par défaut et initialisons ses propriétés.

Constructeur nommé

• Vous pouvez définir plusieurs constructeurs nommés pour une classe.
• Pour déclarer un constructeur nommé, utilisez le nom de la classe suivi de . et du nom du constructeur.
• En Dart il est possible de créer des constructeurs nommés. En principe, en Dart, il n’y a besoin que d’un seul constructeur. Cela étant dû aux possibilités offertes avec les paramètres optionnels. Cependant, il pourrait être pratique d’en posséder plusieurs et de leur donner un nom afin de rendre leur utilité très claire.
• Dans l’exemple de la classe Personne, si un troisième attribut était ajouté comme le numéro de téléphone ou bien l’adresse, il pourrait être utile d’avoir un constructeur complet, mais aussi un autre pour récupérer le nom et le prénom :

// Déclaration de la classe Personne
class Personne {
  // Déclaration de l'attribut 'nom' (public)
  String nom;

  // Déclaration de l'attribut '_prenom' (privé à la bibliothèque Dart car commence par un "_")
  String _prenom;

  // Déclaration de l'attribut 'telephone' (public)
  String telephone;

  // Déclaration de l'attribut 'adresse' (public)
  String adresse;

  // Constructeur par défaut avec initialisation obligatoire du prénom.
  // Les autres attributs sont optionnels et nommés grâce à l'utilisation des accolades.
  // Exemple d'appel : Personne('Ahmed', nom: 'Ali', telephone: '1234', adresse: 'Rue X');
  Personne(this._prenom, {this.nom, this.telephone, this.adresse});

  // Constructeur nommé 'etatCivil' : initialise uniquement le prénom et le nom.
  // Les autres champs ne sont pas pris en charge par ce constructeur.
  // Exemple d'appel : Personne.etatCivil('Ahmed', 'Ali');
  Personne.etatCivil(this._prenom, this.nom);
// Méthode pour afficher les informations
  void afficherInfos() {
    print('Nom complet : $_prenom $nom');
    print('Téléphone : ${telephone ?? "non fourni"}');
    print('Adresse : ${adresse ?? "non fournie"}');
  }
}
//Exemple d’utilisation
void main() {
  // Création d'une personne avec le constructeur principal
  var personne1 = Personne('Karim', nom: 'Zitouni', telephone: '98765432', adresse: 'Nabeul');
  personne1.afficherInfos();

  print('---');

  // Création d'une personne avec le constructeur nommé
  var personne2 = Personne.etatCivil('Nadia', 'Brahimi');
  personne2.afficherInfos();

  print('---');

  // Changer l'adresse d'une personne après sa création
  personne2.adresse = 'Sousse';
  personne2.telephone = '11223344';
  personne2.afficherInfos();
}

 

Les constructeurs nommés sont utilisés lorsqu’on souhaite fournir plusieurs façons de créer un objet, chacune avec des paramètres différents ou une logique spécifique. Cela rend le code plus lisible, plus flexible et souvent plus clair pour les développeurs.

Constructeur paramètré

• Les constructeurs paramétrés en Dart sont des constructeurs qui acceptent des paramètres pour initialiser les propriétés de la classe.
• Le constructeur paramétré (souvent appelé constructeur génératif) est le constructeur de base en Dart. Il permet de passer des valeurs lors de la création de l'objet pour remplir ses propriétés.
• Dart a deux façons de l'écrire : la méthode "classique" (longue) et la méthode "sucre syntaxique" (recommandée).

  1. La forme courte (Sucre syntaxique)

     • C'est la méthode que vous utiliserez 99 % du temps. On utilise this.nom Variable directement dans les parenthèses. Dart comprend qu'il doit prendre l'argument reçu et le mettre dans la variable correspondante.

     class Voiture {
       String marque;
       String modele;
     
       // Constructeur paramétré raccourci
       Voiture(this.marque, this.modele);
     }
     
     void main() {
       var maVoiture = Voiture("Toyota", "Corolla");
     }

  2. La forme longue (Avec liste d'initialisation)

     • Avant, on devait écrire chaque étape. C'est utile si vous voulez faire une petite transformation sur la donnée avant de l'enregistrer (comme mettre une majuscule).

     class Voiture {
       String marque;
       String modele;
     
       // On reçoit 'm' et 'mod', puis on les assigne après les ':'
       Voiture(String m, String mod) 
           : marque = m, 
             modele = mod;
     }

  3. Exemple

  //Déclaration de la classe chat
  class Chat{
    String? nom;
    String? couleur;
    int? age;
    
    //Constructeur basique sans paramètres #1
    Chat();
    //Ou
    //Constructeur basique avec paramètres #2
    Chat(String? nom, String? couleur, int? age){
      this.nom = nom;
      this.couleur = couleur;
      this.age = age;
    }
    
    //Constructeur nommé avec paramètres #3
    Chat.nom(String? nom){
      this.nom = nom;
    }
  
    //Constructeur nommé sans paramètres #4
    Chat.getInstance(){}
  }

Applications

1. App01

   1. Créez une classe appelée `Car` avec les propriétés `make`, `model` et `year`. 2. Ajoutez un constructeur à la classe `Car` qui prend ces trois propriétés comme paramètres et initialise les champs correspondants. 3. Ajoutez une méthode `printDetails()` à la classe `Car` qui imprime les détails de la voiture de la manière suivante : "Make: ..., Model: ..., Year: ...". 4. Dans la fonction main, créez une instance de la classe `Car` en utilisant le constructeur, puis appelez la méthode `printDetails()` sur cette instance.

   void main() {
     // Votre code ici
   }

2. Votre classe Car et son constructeur ici
3. Votre tâche est de compléter ce code en créant la classe Car, en ajoutant le constructeur et la méthode printDetails(), puis en créant une instance de la classe Car dans la fonction main() et en appelant la méthode printDetails() sur cette instance.
Solution

class Car {
  String make;
  String model;
  int year;

  // Constructeur paramétré
  Car(this.make, this.model, this.year);

  // Méthode pour afficher les détails de la voiture
  void printDetails() {
    print('Make: $make, Model: $model, Year: $year');
  }
}

Fonction main() avec création d’une instance

void main() {
  // Création d'une instance de Car
  Car myCar = Car('Toyota', 'Corolla', 2020);

  // Appel de la méthode pour afficher les détails
  myCar.printDetails();
}

4. App02

   • Soit la classe Chien suivant

   class Chien {
     var nom;
     // constructeur simple
     Chien() {
       this.nom = 'inconu';
     }
     // constructeur nommé
     Chien.nom(this.nom);
   }
   
   main() {
     var chien = Chien.nom('Tango');
     print(chien.nom); 
   }

5. Ajoutez une propriété age à la classe Chien. Modifiez les constructeurs pour inclure cette nouvelle propriété.
Solution

class Chien {
  var nom;
  var age;

  Chien() {
    this.nom = 'inconnu';
  }

  Chien.nom(this.nom);

  // Nouveau constructeur nommé avec l'âge
  Chien.nomEtAge(this.nom, this.age);
}

main() {
  var chien1 = Chien.nom('Tango');
  print(chien1.nom);

  var chien2 = Chien.nomEtAge('Bella', 3);
  print(chien2.nom);
  print(chien2.age);
}

6. Ajoutez un constructeur paramétré à la classe Chien qui prend le nom et l'âge comme paramètres.
Solution

class Chien {
  var nom;
  var age;

  Chien() {
    this.nom = 'inconnu';
  }

  Chien.nom(this.nom);

  Chien.nomEtAge(this.nom, this.age);

  // Nouveau constructeur paramétré
  Chien.parametre(this.nom, this.age);
}

main() {
  var chien1 = Chien.nom('Tango');
  print(chien1.nom);

  var chien2 = Chien.nomEtAge('Bella', 3);
  print(chien2.nom);
  print(chien2.age);

  var chien3 = Chien.parametre('Charlie', 2);
  print(chien3.nom);
  print(chien3.age);
}

7. Ajoutez un constructeur nommé Chien. adulte qui crée un chien avec un âge par défaut de 3 ans.
Solution

class Chien {
  var nom;
  var age;

  Chien() {
    this.nom = 'inconnu';
  }

  Chien.nom(this.nom);

  Chien.nomEtAge(this.nom, this.age);

  Chien.parametre(this.nom, this.age);

  // Nouveau constructeur nommé avec une logique spécifique
  Chien.adulte(this.nom) {
    this.age = 3;
  }
}

main() {
  var chien1 = Chien.nom('Tango');
  print(chien1.nom);

  var chien2 = Chien.nomEtAge('Bella', 3);
  print(chien2.nom);
  print(chien2.age);

  var chien3 = Chien.parametre('Charlie', 2);
  print(chien3.nom);
  print(chien3.age);

  var chien4 = Chien.adulte('Max');
  print(chien4.nom);
  print(chien4.age);
}

8. Exercice : La Gestion de Stock "Smartphones"

   • Énoncé
   • Crée une classe Smartphone qui possède trois propriétés :
     • String brand(la marque)
     • String model (le modèle)
     • int price (le prix)
   • Objectifs :
     • Constructeur Paramétré: Crée un constructeur qui initialise les trois propriétés d'un coup.
     • Constructeur Nommé : Crée un constructeur nommé .unknown() qui initialise la marque et le modèle à "Inconnu" et le prix à 0.
     • Constructeur de Redirection: Crée un constructeur nommé .promo(String brand, String model) qui initialise la marque et le modèle avec les valeurs reçues, mais fixe automatiquement le prix à 500 (en appelant le constructeur principal).
     • Méthode : Ajoute une méthode info() qui affiche : "Appareil : [brand] [model], Prix : [price]€".
     Solution

     class Smartphone {
       String brand;
       String model;
       int price;
     
       // 1. Constructeur Paramétré (Le classique)
       Smartphone(this.brand, this.model, this.price);
     
       // 2. Constructeur Nommé (Pour des cas spécifiques)
       Smartphone.unknown()
           : brand = 'Inconnu',
             model = 'Inconnu',
             price = 0;
     
       // 3. Constructeur de Redirection (Pratique pour des valeurs par défaut)
       Smartphone.promo(String brand, String model) : this(brand, model, 500);
     
       void info() {
         print('Appareil : $brand $model, Prix : $price€');
       }
     }
     
     void main() {
       // Test du constructeur paramétré
       var s1 = Smartphone('Apple', 'iPhone 15', 1000);
       
       // Test du constructeur nommé
       var s2 = Smartphone.unknown();
       
       // Test du constructeur promo
       var s3 = Smartphone.promo('Samsung', 'S23');
     
       s1.info(); // Appareil : Apple iPhone 15, Prix : 1000€
       s2.info(); // Appareil : Inconnu Inconnu, Prix : 0€
       s3.info(); // Appareil : Samsung S23, Prix : 500€
     }
     

   • Exercice : Classe Produit & Constructeurs Dart

     • Énoncé :
       • Créer une classe Produit avec des propriétés
         • nom (String)
         • prix (double)
         • quantiteEnStock (int)
         • estDisponible (bool, calculé automatiquement : true si quantiteEnStock > 0)
       • Implémenter un constructeur par défaut
       • Implémenter un constructeur paramétré (avec paramètres nommés)
       • Implémenter un constructeur nommé
       • Utiliser les initialiseurs de liste (:) pour calculer des propriétés dérivées
     Consignes
   • Créez une classe Produit avec les propriétés suivantes :
     • nom (String)
     • prix (double)
     • quantiteEnStock (int)
     • estDisponible (bool, calculé automatiquement : true si quantiteEnStock > 0)
   • Implémentez un constructeur par défaut qui initialise un produit avec : "Inconnu", 0.0, 0, false
   • Implémentez un constructeur paramétré (utilisez des paramètres nommés required) permettant de créer un produit avec des valeurs personnalisées. Calculez estDisponible automatiquement.
   • Implémentez un constructeur nommé Produit.gratuit qui prend uniquement un nom, fixe le prix à 0.0 et la quantité à 10.
   • Ajoutez une méthode afficher() qui imprime les informations du produit sur une seule ligne.
   • Dans main(), testez les 3 constructeurs et appelez afficher() pour chacun.