Les constructeurs de classe dans Dart

• 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é.

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.

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.

2. 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.

3. 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(){}
}