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