Les designs patterns de création - Prototype

Les designs patterns de création c'est quoi ?

Les design patterns de création sont un ensemble de schémas de conception qui permettent de créer des objets d'une manière flexible, modulaire, et qui facilite leur réutilisation. Ils sont utilisés pour résoudre des problèmes de conception liés à la création d'objets. Les design patterns de création les plus couramment utilisés sont les suivants :

• Factory
• Builder
• Prototype
• Singleton

Nous allons ici nous concentrer sur le design pattern prototype.

Le design pattern Prototype

définition

En programmation orientée objet, le design pattern Prototype est utilisé lorsque la création d'une instance est complexe ou consommatrice en temps. Plutôt que créer plusieurs instances de la classe, on copie la première instance et on modifie la copie de façon appropriée.

Pour implémenter ce patron il faut déclarer une classe abstraite spécifiant une méthode virtuelle pure appelée clone(). Toute classe nécessitant un constructeur polymorphique dérivera de cette classe abstraite et implémentera la méthode clone().

Le client de cette classe, au lieu d'écrire du code invoquant directement une nouvelle instance de la classe, appellera la méthode clone() sur le prototype ou utilisera une autre méthode fourni par un autre design pattern.

Cas d'utilisation

1. Création d'objets coûteuse : Lorsqu'il est coûteux de créer un nouvel objet en utilisant le processus d'instanciation habituel, le Prototype permet de cloner un objet existant pour obtenir une copie modifiable, évitant ainsi les coûts de création répétée.

2. Configuration initiale : Lorsqu'un objet nécessite une configuration complexe, mais que certaines parties de la configuration sont identiques pour plusieurs instances, le Prototype permet de cloner un objet préconfiguré au lieu de tout reconfigurer à chaque fois.

3. Génération de données de test : Lorsqu'il est nécessaire de générer de grandes quantités de données de test, le Prototype peut être utilisé pour cloner des objets représentant des données de base et les modifier légèrement pour créer de nouvelles instances de test.

4. Gestion des caches : Lorsque les objets fréquemment utilisés doivent être stockés dans un cache, le Prototype peut être utilisé pour créer des copies de ces objets et les stocker dans le cache. Cela évite de devoir accéder à une source de données externe ou de les recréer à chaque fois.

5. Manipulation d'objets immuables : Lorsque les objets sont immuables et ne peuvent pas être modifiés directement, le Prototype permet de cloner un objet existant, d'apporter des modifications à la copie et d'obtenir ainsi un nouvel objet modifié.

exemple d'implementation

Pour commencer, il nous faut créer l'interface Humain qui définira la méthode clone() qui sera implémenter les classe qui hériterons de l'interface, ici ConcreteHuman

public interface Human {

    public Human getClone();
}

La méthode clone() de ConcreteHuman renverra une nouvelle instance de ConcreteHuman avec les même nom, prenom et age que l'objet d'origine.

public class ConcreteHuman implements Prototype {

    private String name;
    private String lastName;
    private Integer age;

    public ConcreteHuman(String name, String lastName, Integer age) {
        this.name = name;
        this.lastName = lastName;
        this.age = age;
    }

    @Override
    public Prototype getClone() {
        return new ConcreteHuman(name, lastName, age);
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Human human = (Human) o;
        return age == human.age && name.equals(human.name) && lastName.equals(human.lastName);
    }
}

Il ne reste plus qu'à implementez le code permettant de vérifier que la méthode clone() me retourne bien un objet identique à celui d'origine

Prototype erwan = new Human("Erwan", "Le Tutour", 32);
Prototype erwanClone = erwan.getClone();
Assertions.assertEquals(erwan, erwanClone);