Les constructeurs de classe dans Dart
Sommaire
- 1- Présentation
- 2- Syntaxe et utilisation
- 3- Créer un constructeur dans Dart
- 4- Types de constructeurs dans Dart
- 4.1- Constructeur par défaut
- 4.1.1- Syntaxe
- 4.1.2- Exemple
- 4.2- Constructeur nommé
- 4.3- Constructeur de paramètres
- 4.3.1- Syntaxe
- 4.3.2- Exemple
- 5- Applications
- 5.1- App01
- 5.2- App02
- 5.2.1- Cours Flutter
-
Présentation
- Les constructeurs sont 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
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éé.-
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.
-
Types de constructeurs dans Dart
- Il existe plusieurs types de constructeurs dans Dart, comme indiqué ci-dessous.
-
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.).
- 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).
-
Syntaxe
-
Exemple
-
Constructeur nommé
- Ce type de constructeur est la solution au problème d’avoir plusieurs constructeurs portant le même nom. Il vous permet de créer plusieurs constructeurs, chacun avec son propre nom.
- Dans d’autres langages, il est possible de surcharger votre constructeur. Cela signifie que vous pouvez avoir différents constructeurs avec le même nom mais avec une signature différente (ou un ensemble d’arguments différent).
- Dans Dart, ce n’est pas possible, mais il y a un moyen de contourner cela. C’est ce qu’on appelle des constructeurs nommés . Donner à vos constructeurs des noms différents permet à votre classe d’avoir de nombreux constructeurs et également de mieux représenter leurs cas d’utilisation en dehors de la classe.
- Dans cet exemple, lorsque vous créez une instance de la classe Etudiant en utilisant Etudiant(), le constructeur par défaut est appelé, affichant le message « À l’intérieur du constructeur Etudiant ». Lorsque vous créez une instance en utilisant Etudiant.namedConst(‘ET001’), le constructeur nommé namedConst est appelé, affichant la valeur de etCode qui est ‘ET001’.
- Les constructeurs nommés offrent une flexibilité supplémentaire lors de la création d’instances de classe avec différentes initialisations.
- Les constructeurs nommés en Dart sont utiles lorsque vous souhaitez avoir plusieurs façons de créer une instance d’une classe avec des initialisations différentes. Voici un exemple d’application où les constructeurs nommés pourraient être utilisés :
- Dans cet exemple, la classe Person a un constructeur par défaut et un constructeur nommé fromBirthYear. Le constructeur fromBirthYear permet de créer une instance de Person en fournissant le nom de la personne et son année de naissance. L’âge est calculé à partir de l’année de naissance dans ce constructeur nommé.
- L’utilisation de ces constructeurs dans la fonction main démontre comment ils peuvent être utilisés pour créer des instances de la classe Person de différentes manières, offrant une flexibilité dans la manière dont les objets sont initialisés.
-
Constructeur de paramètres
- Nous pouvons également passer les paramètres à un constructeur, ce type de constructeur est appelé constructeur paramétré. Il est utilisé pour initialiser les variables d’instance. Parfois, nous avons besoin d’un constructeur qui accepte un ou plusieurs paramètres. Les constructeurs paramétrés sont principalement utilisés pour initialiser la variable d’instance avec ses propres valeurs. La syntaxe est donnée ci-dessous.
-
Syntaxe
-
Exemple
-
Applications
-
App01
- Votre classe Car et son constructeur ici
- 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.
-
App02
- Soit la classe Chien suivant
- Ajoutez une propriété age à la classe Chien. Modifiez les constructeurs pour inclure cette nouvelle propriété.
- Ajoutez un constructeur paramétré à la classe Chien qui prend le nom et l’âge comme paramètres.
- Ajoutez un constructeur nommé Chien.adulte qui crée un chien avec un âge par défaut de 3 ans.
class_name( [ paramètres ] ){
// Corps du constructeur
}
Les constructeurs n’ont pas de type de retour.
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}");
}
}
class Example {
// Dart crée un constructeur par défaut ici
}
class ClassName {
ClassName() {
// constructor body
}
}
class MyClass {
// Propriétés de la classe
String property1;
int property2;
// Constructeur paramétré
MyClass(String param1, int param2) {
// Initialisation des propriétés avec les paramètres
this.property1 = param1;
this.property2 = param2;
}
// Méthode pour afficher les détails
void printDetails() {
print("Property1: $property1, Property2: $property2");
}
}
void main() {
// Création d'une instance de MyClass en utilisant le constructeur paramétré
MyClass myObject = MyClass("Value1", 42);
// Appel de la méthode pour afficher les détails
myObject.printDetails();
}
void main() {
// Création d'une instance en utilisant le constructeur par défaut
Etudiant emp1 = Etudiant();
// Création d'une instance en utilisant le constructeur nommé 'namedConst'
Etudiant emp2 = Etudiant.namedConst('ET001');
}
class Etudiant {
// Constructeur par défaut
Etudiant() {
print("À l'intérieur du constructeur Etudiant");
}
// Constructeur nommé 'namedConst'
Etudiant.namedConst(String etCode) {
print(etCode);
}
}
void main() {
// Création d'une instance en utilisant le constructeur par défaut
Person person1 = Person.defaultConstructor("John", 25);
// Création d'une instance en utilisant un constructeur nommé
Person person2 = Person.fromBirthYear("Alice", 1990);
// Affichage des détails des personnes
person1.printDetails();
person2.printDetails();
}
class Person {
String name;
int age;
// Constructeur par défaut
Person.defaultConstructor(this.name, this.age);
// Constructeur nommé pour créer une personne à partir de l'année de naissance
Person.fromBirthYear(String name, int birthYear) {
this.name = name;
this.age = DateTime.now().year - birthYear;
}
void printDetails() {
print("Name: $name, Age: $age");
}
}
class ClassName {
ClassName(parameter_list){
// constructor body
}
}
class Etudiant {
Etudiant(String name) {
print("Nom de l'étudiant : ${name}");
}
}
void main() {
Etudiant st = new Etudiant("Riadh!");
}
-
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
}
Solution
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);
}
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);
}
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);
}
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);
}