Les Classes en Dart
Dans le langage Dart, les classes servent de modèle pour créer des objets. Elles jouent un rôle essentiel dans la programmation orientée objet (POO). Les classes définissent les méthodes, les propriétés et le comportement d'un objet.
Prenons un exemple : une classe appelée Phone
pourrait avoir des propriétés telles que .color
et .brand
, en plus de méthodes comme .call()
et .text()
.
Syntaxe des Classes
Voici la syntaxe de base pour définir une classe :
class NomDeLaClasse {
// Corps de la classe
// Propriétés
type nomDeLaPropriete;
// Méthodes
returnType nomDeLaMethode() {
// Corps de la méthode
}
}
- class : le mot-clé pour créer une classe.
- NomDeLaClasse : le nom de la classe, qui suit la convention UpperCamelCase.
Instances de Classe
En Dart, un objet est une instance d'une classe, comprenant des propriétés et des méthodes. Un objet peut être créé uniquement après la définition d'une classe. Pour créer un nouvel objet d'une classe précise, utilisez la syntaxe suivante :
NomDeLaClasse nomObjet = NomDeLaClasse();
Exemple
Voici un exemple qui montre comment créer un objet en Dart :
class Maison {
// Définition des propriétés
String? couleur;
int? nombreChambres;
// Définition d'une méthode
void infoMaison() {
print("Couleur de la maison: \\$couleur");
print("Nombre de chambres: \\$nombreChambres");
}
}
void main() {
// Création d'un objet de la classe `Maison`
Maison maMaison = Maison();
maMaison.couleur = "Blanche";
maMaison.nombreChambres = 5;
maMaison.infoMaison();
}
L'exécution de cet exemple produira :
Couleur de la maison: Blanche
Nombre de chambres: 5
Classes Abstraites
Une classe peut être déclarée comme abstraite en utilisant le mot-clé abstract
. Une classe abstraite ne peut pas être instanciée directement. Son but est de permettre à d'autres classes d'hériter de ses propriétés et méthodes.
Pour déclarer une classe abstraite, vous utilisez la syntaxe :
abstract class NomDeLaClasse {
// Corps de la classe
}
Méthodes Abstraites
Une méthode abstraite est une méthode déclarée sans détails d'implémentation. Elle est définie uniquement par sa signature, suivie d'un point-virgule (;). Les sous-classes doivent fournir les détails d'implémentation pour ces méthodes lorsqu'elles héritent d'une classe abstraite.
Exemple
Le code suivant montre l'utilisation d'une méthode abstraite :
abstract class Animal {
// Définition d'une méthode abstraite
void nourrir();
}
class Chien extends Animal {
@override
void nourrir() {
print('Nourrir le chien...');
}
}
class Chat extends Animal {
@override
void nourrir() {
print('Nourrir le chat...');
}
}
void main() {
Chien monChien = Chien();
monChien.nourrir();
Chat monChat = Chat();
monChat.nourrir();
}
Ce code affichera :
Nourrir le chien...
Nourrir le chat...