Constructeurs factory

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy. Leçon 14 sur 110.

Un constructeur factory est un constructeur spécial qui ne crée pas toujours une nouvelle instance. Contrairement aux constructeurs ordinaires, un constructeur factory peut retourner une instance existante, un sous-type, ou même null (s’il est nullable). Vous le déclarez à l’aide du mot-clé factory.

class Logger {
  static final Logger _instance = Logger._internal();
  
  // Constructeur nommé privé
  Logger._internal();
  
  // Constructeur factory
  factory Logger() {
    return _instance;
  }
}

Logger log1 = Logger();
Logger log2 = Logger();
print(identical(log1, log2)); // true

Dans cet exemple, le constructeur factory renvoie toujours la même instance. Quel que soit le nombre de fois où vous appelez Logger(), vous obtenez exactement le même objet. Ce modèle est couramment utilisé pour implémenter des singletons.

Les constructeurs factory diffèrent des constructeurs ordinaires sur un point essentiel : ils n’ont pas accès à this, car ils peuvent ne pas créer de nouvelle instance du tout. À la place, ils doivent retourner explicitement un objet :

class Shape {
  factory Shape(String type) {
    if (type == 'circle') return Circle();
    if (type == 'square') return Square();
    return Rectangle();
  }
}

class Circle extends Shape { Circle() : super._(); }
class Square extends Shape { Square() : super._(); }
class Rectangle extends Shape { Rectangle() : super._(); }

Les constructeurs factory sont utiles lorsque vous avez besoin de contrôler la création d’une instance, par exemple pour retourner des objets mis en cache, implémenter des pools d’objets ou décider quel sous-type instancier en fonction des paramètres d’entrée.

Défi

Facile

Construisons un système de notifications qui utilise des constructeurs factory pour créer différents types de notifications à partir d'une simple chaîne de caractères.

Vous allez créer deux fichiers pour organiser votre code :

notification.dart : définissez une classe Notification qui sert de base à tous les types de notifications. Votre classe doit comporter :
- Un champ String message
- Un constructeur nommé privé Notification._internal qui initialise le message
- Un constructeur factory Notification(String type, String message) qui renvoie différents sous-types de notifications selon le paramètre type :
  - Si type vaut 'email', renvoyez un EmailNotification
  - Si type vaut 'sms', renvoyez un SMSNotification
  - Sinon, renvoyez un PushNotification
- Une méthode send() qui affiche Sending: [message]

Dans le même fichier, créez trois sous-classes qui étendent Notification :

EmailNotification : redéfinissez send() pour afficher Email: [message]
SMSNotification : redéfinissez send() pour afficher SMS: [message]
PushNotification : redéfinissez send() pour afficher Push: [message]

Chaque sous-classe doit avoir un constructeur qui prend un message et le transmet à la classe parente à l'aide de super._internal(message).

main.dart : importez votre classe de notification et créez trois notifications à l'aide du constructeur factory :
- Une notification par e-mail avec le message 'Welcome!'
- Une notification SMS avec le message 'Your code is 1234'
- Une notification push avec le message 'New update available'
Appelez send() sur chaque notification dans l'ordre indiqué ci-dessus.

Sortie attendue :

Email: Welcome!
SMS: Your code is 1234
Push: New update available

Essayez vous-même

import 'notification.dart';

void main() {
  // TODO: Créer une notification e-mail avec le message 'Welcome!'
  
  // TODO: Create an SMS notification with message 'Your code is 1234'
  
  // TODO: Create a push notification with message 'New update available'
  
  // TODO: Appeler send() sur chaque notification dans l'ordre
}