Introduction à la programmation orientée objet en Dart

class Personne {
  String nom;
  int age;
  
  void direBonjour() {
    print("Bonjour, je m'appelle $nom et j'ai $age ans.");
  }
}

Personne personne = new Personne();

var personne = new Personne();

personne.nom = "John Doe";

personne.direBonjour(); // Affiche "Bonjour, je m'appelle John Doe et j'ai ... ans."

1. Champs Privés :

• En Dart, l’encapsulation est souvent mise en œuvre en déclarant les champs comme privés en les préfixant d’un underscore _.

class Person {
  String _name; // Champ privé
  int _age;     // Champ privé

  Person(this._name, this._age);
}

• Ces champs privés ne sont pas accessibles directement depuis l’extérieur de la classe.

2. Accès Contrôlé :

• Pour permettre l’accès aux données encapsulées, des méthodes publiques (getters et setters) sont souvent définies.

class Person {
  String _name; // Champ privé
  int _age;     // Champ privé

  Person(this._name, this._age);

  // Getter
  String get name => _name;

  // Setter
  set age(int value) {
    if (value >= 0) {
      _age = value;
    } else {
      print('L\'âge ne peut pas être négatif.');
    }
  }
}

• Ces méthodes permettent un accès contrôlé aux données internes de la classe, permettant la validation ou la modification des valeurs avant ou après leur accès.

3. Protection contre la Modification Directe :

• L’encapsulation protège contre la modification directe des champs privés en dehors de la classe, réduisant ainsi le risque d’erreurs et facilitant la maintenance du code.

4. Modification de l’Implémentation sans Impact Extérieur :

• En encapsulant les détails internes de la classe, vous pouvez changer l’implémentation sans affecter le reste du programme. Tant que les méthodes publiques restent inchangées, le code client n’a pas besoin d’être modifié.

En résumé, l’encapsulation en Dart favorise la modularité, la réutilisation du code et la réduction des erreurs en restreignant l’accès direct aux détails internes de la classe. Elle encourage la définition d’interfaces publiques bien définies pour interagir avec les objets plutôt que de manipuler directement leurs états internes.

1. Déclaration d’une Classe avec Héritage :

• En Dart, pour déclarer une classe qui hérite d’une autre, on utilise le mot-clé extends.

class Person {
  String name;
  int age;

  Person(this.name, this.age);

  void printInfo() {
    print('Nom: $name, Âge: $age');
  }
}

class Employee extends Person {
  String department;

  Employee(String name, int age, this.department) : super(name, age);

  void printEmployeeInfo() {
    super.printInfo(); // Appel à la méthode de la classe de base
    print('Département: $department');
  }
}

• Dans cet exemple, la classe Employee hérite de la classe Person. La classe Employee a donc accès aux propriétés et méthodes de la classe Person, en plus de ses propres membres.

2. Appel à la Classe de Base avec super :

• Le mot-clé super est utilisé pour appeler les membres (méthodes ou propriétés) de la classe de base à partir de la classe dérivée.

void printEmployeeInfo() {
  super.printInfo(); // Appel à la méthode printInfo() de la classe de base
  print('Département: $department');
}

3. Surcharge de Méthodes (Override) :

• Une classe dérivée peut redéfinir (ou surcharger) une méthode de la classe de base en utilisant le mot-clé @override.

@override
void printInfo() {
  print('Employé - Nom: $name, Âge: $age');
}

• Cela permet à la classe dérivée de fournir une implémentation spécifique pour la méthode, tout en conservant la structure générale de la classe de base.

4. Constructeurs dans les Classes Dérivées :

• Les classes dérivées peuvent appeler le constructeur de la classe de base en utilisant super dans leur propre constructeur.

Employee(String name, int age, this.department) : super(name, age);

5. Utilisation de l’Héritage pour la Réutilisation du Code :

• L’héritage permet de réutiliser le code en évitant la duplication. Les membres communs à plusieurs classes peuvent être placés dans une classe de base, tandis que les classes dérivées peuvent se concentrer sur leurs spécificités.

void main() {
  Employee employee = Employee('Alice', 30, 'Informatique');
  employee.printEmployeeInfo();
}

• En résumé, l’héritage en Dart offre une manière puissante de créer des relations entre les classes, favorisant la réutilisation du code et permettant une gestion hiérarchique des fonctionnalités au sein d’une application.

1. Polymorphisme de sous-typage (Polymorphisme d’héritage):

• Le polymorphisme de sous-typage est basé sur l’héritage. Dart prend en charge l’héritage simple, et les classes peuvent hériter d’une seule classe à la fois.
• Voici un exemple simple de polymorphisme de sous-typage en Dart :

class Animal {
  void faireDuBruit() {
    print('Certains animaux font du bruit.');
  }
}

class Chien extends Animal {
  @override
  void faireDuBruit() {
    print('Le chien aboie.');
  }
}

class Chat extends Animal {
  @override
  void faireDuBruit() {
    print('Le chat miaule.');
  }
}

void main() {
  Animal animal = Chien();
  animal.faireDuBruit(); // Le chien aboie.

  animal = Chat();
  animal.faireDuBruit(); // Le chat miaule.
}

• Dans cet exemple, la classe Animal est la classe de base, et les classes Chien et Chat héritent de la classe Animal. Les méthodes spécifiques de chaque classe dérivée (chien et chat) peuvent être appelées via une référence de type Animal.

2. Polymorphisme d’interface:

• Dart prend également en charge le polymorphisme d’interface. Les interfaces définissent un contrat que les classes peuvent implémenter. Voici un exemple d’interface en Dart :

abstract class Animal {
  void faireDuBruit();
}

class Chien implements Animal {
  @override
  void faireDuBruit() {
    print('Le chien aboie.');
  }
}

class Chat implements Animal {
  @override
  void faireDuBruit() {
    print('Le chat miaule.');
  }
}

void main() {
  Animal animal = Chien();
  animal.faireDuBruit(); // Le chien aboie.

  animal = Chat();
  animal.faireDuBruit(); // Le chat miaule.
}

• Dans cet exemple, Animal est une interface, et les classes Chien et Chat implémentent cette interface. Le polymorphisme d’interface permet d’utiliser différentes classes de manière interchangeable, pourvu qu’elles respectent le contrat défini par l’interface.

Le polymorphisme en Dart offre une flexibilité qui facilite la création de code réutilisable et extensible. En choisissant le type d’héritage ou d’interface approprié, les développeurs peuvent concevoir des systèmes logiciels plus modulaires et évolutifs.

// Classe de base
class Animal {
  void faireDuBruit() {
    print('Le son de l\'animal');
  }
}

// Classes dérivées
class Chien extends Animal {
  @override
  void faireDuBruit() {
    print('Le chien aboie');
  }
}

class Chat extends Animal {
  @override
  void faireDuBruit() {
    print('Le chat miaule');
  }
}

// Fonction utilisant le polymorphisme
void ecouterAnimal(Animal animal) {
  animal.faireDuBruit();
}

void main() {
  // Utilisation du polymorphisme
  Animal animal1 = Chien();
  Animal animal2 = Chat();

  ecouterAnimal(animal1); // Le chien aboie
  ecouterAnimal(animal2); // Le chat miaule
}