Méthodes abstraites

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy — leçon 44 sur 110.

Une méthode abstraite est une méthode déclarée à l'intérieur d'une classe abstraite qui n'a pas de corps. Elle définit la signature de la méthode mais laisse l'implémentation à chaque sous-classe. Toute classe qui étend la classe abstraite doit redéfinir toutes les méthodes abstraites, sinon elle sera également abstraite.

abstract class Animal {
  // Méthode abstraite - pas de corps, doit être implémentée par les sous-classes
  String makeSound();

  // Méthode concrète - possède un corps, partagée par toutes les sous-classes
  void breathe() {
    print('Breathing...');
  }
}

class Dog extends Animal {
  @override
  String makeSound() {
    return 'Woof!';  // Doit fournir une implémentation
  }
}

class Cat extends Animal {
  @override
  String makeSound() {
    return 'Meow!';  // Implémentation différente, même signature
  }
}

Si une sous-classe oublie d'implémenter une méthode abstraite, Dart vous donnera une erreur de compilation. C'est tout l'intérêt : les méthodes abstraites imposent un contrat. Chaque sous-classe est garantie d'avoir cette méthode, vous pouvez donc l'appeler en toute sécurité sur n'importe quelle instance du type abstrait.

// Vous pouvez utiliser le type abstrait comme type de variable
Animal a = Dog();
print(a.makeSound());  // Ouaf !

Animal b = Cat();
print(b.makeSound());  // Miaou !

Les méthodes abstraites sont différentes des méthodes concrètes dans une classe abstraite. Les méthodes concrètes ont un corps et sont héritées telles quelles. Les méthodes abstraites n'ont pas de corps et doivent être redéfinies.

Vous pouvez mélanger les deux dans la même classe abstraite pour partager certains comportements tout en forçant les sous-classes à définir les leurs pour d'autres.

Caractéristique	Méthode abstraite	Méthode concrète
Possède un corps	Non	Oui
Doit être redéfinie	Oui	Non
Objectif	Imposer un contrat	Partager un comportement
Emplacement	Classe abstraite uniquement	N'importe quelle classe

Défi

Facile

Construisons un calculateur de formes qui démontre les méthodes abstraites en action. Vous allez définir une classe abstraite avec des méthodes abstraites que chaque forme doit implémenter différemment, puis utiliser ces formes via une interface commune.

Vous organiserez votre code en quatre fichiers :

shape.dart : Définissez une classe abstraite Shape avec un champ final color (String) et un constructeur qui l'initialise. Déclarez deux méthodes abstraites : double area() et double perimeter(). Ajoutez également une méthode concrète describe() qui affiche A [color] shape with area: [area] and perimeter: [perimeter]. Parce que area() et perimeter() sont abstraites, chaque sous-classe fournira son propre calcul, mais describe() fonctionne pour toutes sans être redéfinie.
circle.dart : Créez une classe Circle qui étend Shape. Elle possède un champ final radius (double). Son constructeur prend color et radius et passe color à super. Implémentez area() pour retourner 3.14 * radius * radius et perimeter() pour retourner 2 * 3.14 * radius.
rectangle.dart : Créez une classe Rectangle qui étend Shape. Elle possède des champs final width et height (tous deux double). Son constructeur prend color, width et height et passe color à super. Implémentez area() pour retourner width * height et perimeter() pour retourner 2 * (width + height).
main.dart : Importez tous les fichiers. Créez un Circle avec la couleur 'red' et un rayon de 5.0, et un Rectangle avec la couleur 'blue', une largeur de 4.0 et une hauteur de 6.0. Appelez describe() sur chaque forme. Ensuite, créez une List<Shape> contenant les deux formes, parcourez la liste et affichez Area: [area] pour chaque forme.

Sortie attendue :

A red shape with area: 78.5 and perimeter: 31.400000000000002
A blue shape with area: 24.0 and perimeter: 20.0
Area: 78.5
Area: 24.0

Aide-mémoire

Une méthode abstraite est une méthode déclarée dans une classe abstraite sans corps. Les sous-classes doivent la redéfinir pour fournir leur propre implémentation.

abstract class Animal {
  // Méthode abstraite - pas de corps
  String makeSound();

  // Méthode concrète - possède un corps
  void breathe() {
    print('Breathing...');
  }
}

Les sous-classes doivent implémenter toutes les méthodes abstraites :

class Dog extends Animal {
  @override
  String makeSound() {
    return 'Woof!';
  }
}

class Cat extends Animal {
  @override
  String makeSound() {
    return 'Meow!';
  }
}

Vous pouvez utiliser le type abstrait comme type de variable :

Animal a = Dog();
print(a.makeSound());  // Woof!

Animal b = Cat();
print(b.makeSound());  // Meow!

Caractéristique	Méthode abstraite	Méthode concrète
Possède un corps	Non	Oui
Doit être redéfinie	Oui	Non
Objectif	Imposer un contrat	Partager un comportement
Où	Classe abstraite uniquement	N'importe quelle classe

Essayez vous-même

import 'shape.dart';
import 'circle.dart';
import 'rectangle.dart';

void main() {
  // TODO: Créer un Circle avec la couleur 'red' et un rayon de 5.0

  // TODO: Créer un Rectangle avec la couleur 'blue', une largeur de 4.0 et une hauteur de 6.0

  // TODO: Appeler describe() sur le cercle

  // TODO: Appeler describe() sur le rectangle

  // TODO: Créer une List<Shape> contenant les deux formes

  // TODO: Parcourir la liste et afficher "Area: [area]" pour chaque forme
}