Classes et objets dans dart

Objectis

Comprendre le concept fondamental d’objets en programmation et comment il diffère d’autres paradigmes de programmation.
Etre capables de créer des classes en Dart. Cela comprend la définition de propriétés et de méthodes, ainsi que la compréhension de la visibilité des membres (public, privé, protégé).

introduction-a-la-programmation-orientee-objet-dans-dart

Présentation

Les classes et les objets Dart sont les concepts fondamentaux du langage de programmation orienté objet.
Une classe est un plan ou un prototype défini par l’utilisateur qui est utilisé pour créer des objets.
Un objet représente des entités de la vie réelle. Les objets déterminent le comportement d’une classe.

Déclarer et instancier une classe dans dart

Structure générale d’une classe Dart

Classes et objets dans dart

Déclarer une classe dans dart

Les classes dans Dart sont déclarées à l’aide du mot-clé class :

class Personne{ /* ... */ }

La déclaration de classe comprend le nom de la classe, l’en-tête de la classe (spécifiant ses paramètres de type, le constructeur principal, etc.) et le corps de la classe, entourés d’accolades.
L’en-tête et le corps sont facultatifs : si la classe n’a pas de corps, les accolades peuvent être omises. personne de classe ;
Une définition de classe commence par le mot clé class suivi du nom de la classe ; et le corps de la classe entouré d’une paire d’accolades.

Syntaxe -1-

class class_name { <fields> <getters/setters> <constructors> <functions> }

Syntaxe -2-

class class_name { // Properties (Variables) // Constructor // Methods or Functions // Getters and Setters }

Explication

Champs(<fields>) – Un champ est une variable déclarée dans une classe. Les champs représentent des données relatives aux objets.
Setters et Getters – Permet au programme d’initialiser et de récupérer les valeurs des champs d’une classe. Un getter/setter par défaut est associé à chaque classe. Cependant, ceux par défaut peuvent être remplacés en définissant explicitement un setter/getter.
Constructeurs (<constructors>) – responsables de l’allocation de mémoire pour les objets de la classe.
Fonctions (<functions>)– Les fonctions représentent les actions qu’un objet peut entreprendre. Ils sont aussi parfois appelés méthodes

Création d’instances de classes dans dart

Après avoir créé la classe, nous pouvons créer une instance ou un objet de cette classe dont nous voulons accéder à ses champs et fonctions.
La création d’instances de classes en Dart se fait en utilisant le mot-clé new suivi du nom de la classe, suivi éventuellement de parenthèses.

var p1 = Personne();

var p2 = Personne();

Le code suivant a le même effet, mais utilise le mot clé facultatif new avant le nom du constructeur (à noter que dans Dart 2, l’utilisation de new est généralement évitée) :

var p1 = new Personne();

var p2 = new Personne();

Exemples

Exemple de base

// Définition d'une classe
class Personne {
  String nom;
  int age;

  // Constructeur
  Personne(this.nom, this.age);

  // Méthode
  void sePresenter() {
    print('Je m\'appelle $nom et j\'ai $age ans.');
  }
}

void main() {
  // Création d'instances de la classe Personne
  var personne1 = Personne('Alice', 25);
  var personne2 = Personne('Bob', 30);

  // Appel de la méthode sur les instances
  personne1.sePresenter();
  personne2.sePresenter();
}

Dans cet exemple, la classe Personne a deux propriétés (nom et age), un constructeur qui permet d’initialiser ces propriétés lors de la création d’une instance, et une méthode sePresenter() qui imprime une phrase présentant la personne.

La création d’instances se fait avec le constructeur Personne en utilisant le mot-clé new (qui est optionnel en Dart) et en fournissant les arguments nécessaires au constructeur. Ensuite, les méthodes de ces instances peuvent être appelées comme n’importe quelle autre fonction ou méthode en Dart.

Il est à noter que depuis Dart 2, le mot-clé new est facultatif lors de la création d’instances, et vous pouvez simplement utiliser le nom de la classe suivi des arguments du constructeur.

Autres Exemplex

Exemple -1-

void main() {
  var premiereVoiture = Voiture();

  premiereVoiture.nom = 'Mazda';
  premiereVoiture.couleur = 'Blanche';

  print(
      'Le nom de la 1ère Voiture est ${premiereVoiture.nom} et la couleur est ${premiereVoiture.couleur}');
  premiereVoiture.conduite();

  var deuxiemeVoiture = Voiture();
  deuxiemeVoiture.nom = 'Honda Fit';
  deuxiemeVoiture.couleur = 'Noir';
  print(
      'Le nom de la 2ème Voiture est ${deuxiemeVoiture.nom} et la couleur est ${deuxiemeVoiture.couleur}');
  deuxiemeVoiture.frein();
}

class Voiture {
  //Propriétés
  late String couleur, nom;
  //Méthodes
  void conduite() {
    print('La voiture roule');
  }

  void frein() {
    print('Le frein a été appliqué');
  }
}

Exemple -2-

class Etudiant {
  var name;
  var age;
  var roll_num;
  displayEtudiantInfo() {
    print('Le nom de l\'étudiant est : ${name}');
    print('L\'âge de l\'étudiant est : ${age}');
    print('Le matricule de l\'étudiant est : ${roll_num}');
  }
}

void main() {
  Etudiant S1 = new Etudiant();
  S1.name = "Emma";
  S1.age = 28;
  S1.roll_num = 2014;
  S1.displayEtudiantInfo();
}

Explication

Dans le deuxième exemple, nous avons créé la classe Etudiant dans Dart avec le mot-clé « class » suivi du nom de la classe.
Ensuite, à l’intérieur de cette classe, nous avons défini trois variables membres, c’est-à-dire name, age et roll_num.
Nous avons également créé une fonction membre de cette classe nommée displayStudentInfo(). Cette fonction n’a pas de type de retour et n’accepte aucun paramètre.
Dans cette fonction, nous affichons simplement les valeurs des variables membres sur le terminal. Maintenant, pour accéder aux variables membres et à la fonction membre de la classe Etudiant, nous avons créé un objet de cette classe, « S1« , dans notre fonction « main() » en utilisant le mot-clé « new« .
Ensuite, nous avons voulu initialiser toutes les variables membres de cette classe.
Pour cela, nous avons initialisé ces variables membres une par une en y accédant avec l’objet de la classe Etudiant que nous avons créé.
Nous avons attribué des valeurs aléatoires à ces trois variables membres. Ensuite, nous venons d’appeler la fonction « displayStudentInfo() » de la classeEtudiant à l’aide de son objet pour afficher toutes les informations de l’élève spécifié sur le terminal.

Objet

Dans Dart, une classe est une plante pour créer des objets. Les objets sont des instances d’une classe.
Un objet est un champ de donnée possédant des attributs ou propriétés et un comportement unique. Par exemple, une facture, un utilisateur, un étudiant, une personne, un Bouton, une balise HTML peut être considéré comme un objet. Un objet personne peut être caractérisé par son nom, sa ville de résidence, son année de naissance. Un objet personne peut avoir des comportements ou effectuer des opérations tel que parler, danser, Jouer d’un instrument…
Ses caractéristiques de personne, dans le paradigme objet, sont appelées attributs ou propriétés et les opérations sont appelées méthodes.
En POO, les choses deviennent plus intéressant quand les objets communiquent entre eux.
Ainsi, un objet encapsule les données et de la logique. Ses données et logique doivent être regroupées au sein d’une même entité appelée classe(class en anglais et mot clef utilisé dans la plupart des langage de POO).

Créer un objet

En Dart, pour créer un objet, vous devez suivre les étapes suivantes :

Définir une classe

Une classe est un modèle qui décrit la structure et le comportement d’un objet. Vous pouvez définir une classe en utilisant le mot-clé class, suivi du nom de la classe et des membres de la classe (propriétés et méthodes).

class Personne { String nom; int age; }

Instancier un objet

Une fois que vous avez défini une classe, vous pouvez créer une instance de cette classe en utilisant le constructeur de la classe. Le constructeur est une méthode spéciale portant le même nom que la classe.

Personne personne = Personne();

Dans cet exemple, nous créons une instance de la classe Personne en utilisant le constructeur par défaut (sans paramètres) de la classe. La variable personne est maintenant une référence à l’objet créé.

Accéder aux membres de l’objet

Une fois que vous avez créé un objet, vous pouvez accéder à ses membres (propriétés et méthodes) en utilisant la notation de point (.) suivie du nom du membre.

personne.nom = 'Alice'; personne.age = 25;

Dans cet exemple, nous utilisons la notation de point pour accéder aux propriétés nom et age de l’objet personne et leur attribuer des valeurs.

Applications

App01

Soit le programme suivant :

Refactorisez ce code en créant une classe Person qui contiendra les propriétés name, age, height.

Cette classe devrait avoir une méthode printDescription() qui peut être utilisée pour imprimer le nom, l’âge et la taille comme dans le programme ci-contre.

Une fois cela fait, créez deux instances de Person et utilisez-les pour appeler la méthode printDescription() que vous venez de créer.

void main() {
  final person = {
    'name': 'Mohamed',
    'age': 36,
    'height': 1.84
  };
  print("Je m'appelle ${person['name']}. J'ai ${person['age']} ans, je mesure ${person['height']} mètres.");
}

Solution

class Person {
  String name;
  int age;
  double height;

  Person(this.name, this.age, this.height);

  void printDescription() {
    print("Je m'appelle $name. J'ai $age ans, je mesure $height mètres.");
  }
}

void main() {
  // Création de deux instances de la classe Person
  Person person1 = Person('Mohamed', 36, 1.84);
  Person person2 = Person('Alice', 25, 1.68);

  // Utilisation de la méthode printDescription()
  person1.printDescription();
  person2.printDescription();
}

App02

Déclarez une classe appelée Etudiant avec les propriétés suivantes :

nom (String)
age (int)
note (double)

Ajoutez un constructeur à la classe Etudiant pour initialiser ces propriétés lors de la création d’une instance.
Ajoutez une méthode afficherInfo() à la classe Etudiant qui imprime les informations de l’étudiant, y compris son nom, son âge et sa note.
Instanciez deux étudiants avec des informations différentes et appelez la méthode afficherInfo() sur chaque instance pour afficher leurs détails.

Solution

class Etudiant {
  String nom;
  int age;
  double note;

  // Constructeur
  Etudiant(this.nom, this.age, this.note);

  // Méthode pour afficher les informations de l'étudiant
  void afficherInfo() {
    print('Nom: $nom, Age: $age, Note: $note');
  }
}

void main() {
  // Instanciation d'étudiants
  var etudiant1 = Etudiant('Alice', 20, 85.5);
  var etudiant2 = Etudiant('Bob', 22, 90.0);

  // Appel de la méthode pour afficher les informations
  etudiant1.afficherInfo();
  etudiant2.afficherInfo();
}

App03

Déclarez une classe appelée Voiture avec les propriétés suivantes :

marque (String)
modele (String)
annee (int)
vitesse (double)

Ajoutez un constructeur à la classe Voiture pour initialiser ces propriétés lors de la création d’une instance.
Ajoutez une méthode accelerer(double augmentation) à la classe Voiture qui prend en paramètre une augmentation de vitesse et met à jour la propriété vitesse en conséquence.
Instanciez une voiture avec des informations de votre choix, puis appelez la méthode accelerer() avec une augmentation de vitesse et affichez la vitesse résultante.

Solution

class Voiture {
  String marque;
  String modele;
  int annee;
  double vitesse;

  // Constructeur
  Voiture(this.marque, this.modele, this.annee, this.vitesse);

  // Méthode pour accélérer la voiture
  void accelerer(double augmentation) {
    vitesse += augmentation;
    print('La voiture accélère à une vitesse de $vitesse km/h.');
  }
}

void main() {
  // Instanciation d'une voiture
  var maVoiture = Voiture('Toyota', 'Camry', 2022, 60.0);

  // Appel de la méthode pour accélérer la voiture
  maVoiture.accelerer(20.0);
}

App04

Déclarez une classe appelée Book avec les propriétés suivantes :

title (String)
author (String)
pageCount (int)

Ajoutez un constructeur à la classe Book pour initialiser ces propriétés lors de la création d’une instance.
Ajoutez une méthode printInfo() qui affiche les informations du livre de la même manière que dans le programme actuel.
Créez ensuite deux instances de la classe Book et utilisez-les pour appeler la méthode printInfo().

Solution

void main() {
  final book1 = {
    'title': 'The Great Gatsby',
    'author': 'F. Scott Fitzgerald',
    'pageCount': 180
  };

  final book2 = {
    'title': 'To Kill a Mockingbird',
    'author': 'Harper Lee',
    'pageCount': 281
  };

  printBookInfo(book1);
  printBookInfo(book2);
}

void printBookInfo(Map book) {
  print("Title: ${book['title']}, Author: ${book['author']}, Page Count: ${book['pageCount']}");
}

App05

Créez une classe Vehicule qui a les caractéristiques suivantes :

Un booléen moteur.
Un entier vitesseMax.
Un constructeur pour initialiser ces caractéristiques.
Une méthode String toString() pour afficher les caractéristiques du véhicule.
Une méthode void Vmax() pour afficher la vitesse maximale du véhicule.

Ensuite, créez une classe VoitureComposee qui a les membres suivants :

Un objet de type Vehicule (ve).
Un entier nombreDePortes.
Une classe VoitureDerivee dérivée de Vehicule avec la donnée membre nombreDePortes.

Définissez les constructeurs et les méthodes toString() pour les deux classes. Comparez les deux implantations et expliquez comment on accède aux différentes données membres et aux différentes méthodes des classes VoitureComposee et VoitureDerivee. Affichez la vitesse maximale de la voiture dans les deux cas.

Solution

class Vehicule {
  bool moteur;
  int vitesseMax;

  Vehicule(this.moteur, this.vitesseMax);

  @override
  String toString() {
    return "Caractéristiques du véhicule : moteur = $moteur, vitesse maximale = $vitesseMax";
  }

  void Vmax() {
    print("Vitesse maximale du véhicule : $vitesseMax");
  }
}

class VoitureComposee {
  Vehicule ve;
  int nombreDePortes;

  VoitureComposee(this.ve, this.nombreDePortes);

  @override
  String toString() {
    return "Caractéristiques de la voiture composée : $ve, nombre de portes = $nombreDePortes";
  }

  void afficherVitesseMax() {
    ve.Vmax();
  }
}

class VoitureDerivee extends Vehicule {
  int nombreDePortes;

  VoitureDerivee(bool moteur, int vitesseMax, this.nombreDePortes)
      : super(moteur, vitesseMax);

  @override
  String toString() {
    return "Caractéristiques de la voiture dérivée : moteur = $moteur, vitesse maximale = $vitesseMax, nombre de portes = $nombreDePortes";
  }
}

void main() {
  // Exemple d'utilisation
  Vehicule vehicule = Vehicule(true, 200);
  print(vehicule.toString());
  vehicule.Vmax();

  VoitureComposee voitureComposee = VoitureComposee(vehicule, 4);
  print(voitureComposee.toString());
  voitureComposee.afficherVitesseMax();

  VoitureDerivee voitureDerivee = VoitureDerivee(true, 220, 2);
  print(voitureDerivee.toString());
  voitureDerivee.Vmax();
}

App06

Créez une classe Liquide contenant seulement une méthode imprimer() qui affiche : « je suis un liquide »
Créez 2 classes dérivées de la classe Liquide, les classes Cafe et Lait, dont les méthodes imprimer() affichent respectivement « je suis un Café », « je suis du Lait »
Enfin créerez une classe Tasse ayant un attribut l de la classe Liquide et une méthode AjouterLiquide (Liquide li) et une méthode imprimer()
Testez l’utilisation : créer un tableau de Tasses qui contient différents liquides

Solution

class Liquide {
  void imprimer() {
    print("je suis un liquide");
  }
}

class Cafe extends Liquide {
  @override
  void imprimer() {
    print("je suis du cafe");
  }
}

class Lait extends Liquide {
  @override
  void imprimer() {
    print("je suis du lait");
  }
}

class Tasse {
  Liquide l;

  void ajouterLiquide(Liquide l) {
    this.l = l;
  }

  void imprimer() {
    l.imprimer();
  }
}

void main() {
  Tasse latasse;
  latasse = Tasse();
  latasse.ajouterLiquide(Liquide());
  latasse.imprimer();

  latasse = Tasse();
  latasse.ajouterLiquide(Cafe());
  latasse.imprimer();

  List lestasses = List.generate(3, (index) => Tasse());

  lestasses[0].ajouterLiquide(Cafe());
  lestasses[1].ajouterLiquide(Lait());
  lestasses[2].ajouterLiquide(Liquide());

  for (int i = 0; i < 3; i++) {
    lestasses[i].imprimer();
  }
}

Dart

Classes et objets dans dart