Modèle de conception - Explication détaillée du modèle de prototype

Préface

• Introduction aux modèles de conception
• Les modèles de conception sont des solutions à des problèmes courants dans le développement de logiciels. Ce sont des idées et des solutions de conception réutilisables résumées par la pratique et l'expérience. Les modèles de conception aident les développeurs à écrire plus efficacement du code de haute qualité en fournissant des structures, des principes et des conseils communs.
  Les modèles de conception sont divisés en trois catégories principales :

1. Modèle de création : se concentre sur le processus de création d'objets, y compris la manière d'instancier des objets, de masquer les détails de la création d'objets et de copier et cloner des objets.
2. Modèles structurels : concentrez-vous sur la manière dont les objets et les classes sont combinés pour atteindre l'objectif d'une structure plus large, telle que les relations entre les classes.
3. Modèles comportementaux : concentrez-vous sur la façon dont les classes et les objets interagissent et communiquent pour obtenir une meilleure collaboration et un meilleur contrôle.

• Introduction au modèle de prototype
  Le modèle de prototype est un type de modèle de création qui se concentre sur la copie et le clonage d'objets. Dans certains cas, la création de nouveaux objets via l’instanciation traditionnelle peut s’avérer extrêmement coûteuse ou complexe. À l'heure actuelle, le modèle prototype fournit une méthode alternative pour créer de nouveaux objets en clonant des objets existants, évitant ainsi le processus d'initialisation coûteux.

Le modèle de prototype peut économiser des ressources et du temps et améliorer l'efficacité de la création d'objets en utilisant la méthode de clonage pour générer de nouveaux objets. Il convient aux scénarios dans lesquels un grand nombre d'objets similaires doivent être créés. Il présente également une bonne évolutivité et peut implémenter une logique de clonage personnalisée en héritant et en remplaçant la méthode de clonage selon les besoins.

Pour résumer, le modèle de prototype est un modèle de conception qui crée de nouveaux objets en clonant des objets existants. Il fournit un moyen flexible et efficace de créer des objets, ce qui peut améliorer considérablement la réutilisabilité et la maintenabilité du code dans certains scénarios.

Base théorique

1. Définition du modèle de prototype

Le modèle de prototype est un modèle de conception créationnel qui permet de créer de nouveaux objets en clonant des objets existants sans recourir au processus d'instanciation traditionnel. Ce modèle crée un nouvel objet indépendant en copiant les propriétés et l'état d'un objet existant, et ses propriétés spécifiques peuvent être modifiées selon les besoins.

Dans le modèle de prototype, nous définissons une classe prototype abstraite qui contient une méthode abstraite pour cloner un objet. La classe prototype concrète hérite de la classe prototype abstraite et implémente la méthode clone pour renvoyer une copie clonée d'elle-même. Le code client utilise une instance de la classe prototype concrète et appelle sa méthode clone pour créer un nouvel objet.

L'idée clé du modèle de prototype est de créer de nouveaux objets à partir d'objets existants plutôt que de démarrer un nouveau processus d'instanciation à partir de zéro. En clonant des objets existants, vous pouvez éviter les travaux d'initialisation répétés et la consommation de ressources, et améliorer l'efficacité de la création d'objets. Dans le même temps, le mode prototype rend également la création d'objets plus flexible et peut être modifié et personnalisé selon les besoins.

2. Rôle du prototype

• classe de prototype abstrait
• cours de prototypes concrets
• client

3. Processus de travail du mode prototype

4. Avantages et inconvénients du modèle de prototype

Application pratique

1. Scénarios applicables du mode prototype

• Le processus d'initialisation de l'objet prend plus de temps
• L'initialisation de classe consomme beaucoup de ressources
• Créer des objets via new est plus compliqué
• Nécessité d'éviter d'utiliser des sous-classes de classes pour la configuration initiale

2. Étapes de mise en œuvre du modèle de prototype

• Créer une classe de prototype abstrait
• Créer une classe de prototype concret
• Créer une classe client

3. La différence entre le modèle prototype et le modèle singleton

Variations du modèle de prototype

1. Modèle de prototype avec gestionnaire de prototypes

• Modèle de prototype avec gestionnaire de prototypes :
  Le modèle de prototype avec gestionnaire de prototypes est une extension du modèle de prototype. Il introduit un gestionnaire de prototypes (Prototype Manager) pour gérer de manière centralisée les objets prototypes. Le gestionnaire de prototypes agit comme un registre pour stocker et récupérer divers objets prototypes.

Cette variante du modèle de prototype facilite la création et la gestion de plusieurs objets prototypes de différents types. Le client peut obtenir l'objet prototype requis via le gestionnaire de prototypes sans appeler explicitement la méthode clone. Le gestionnaire de prototypes peut gérer en interne une collection d'objets prototypes, les copier et les renvoyer si nécessaire.

• Implémentation du code de modèle de prototype avec le gestionnaire de prototypes :

import java.util.HashMap;
import java.util.Map;

// 原型接口
interface Prototype {
    
    
    Prototype clone();
}

// 具体原型类 A
class ConcretePrototypeA implements Prototype {
    
    
    private String name;

    public ConcretePrototypeA(String name) {
    
    
        this.name = name;
    }

    public String getName() {
    
    
        return name;
    }

    @Override
    public Prototype clone() {
    
    
        return new ConcretePrototypeA(this.name);
    }
}

// 具体原型类 B
class ConcretePrototypeB implements Prototype {
    
    
    private int number;

    public ConcretePrototypeB(int number) {
    
    
        this.number = number;
    }

    public int getNumber() {
    
    
        return number;
    }

    @Override
    public Prototype clone() {
    
    
        return new ConcretePrototypeB(this.number);
    }
}

// 原型管理器
class PrototypeManager {
    
    
    private Map<String, Prototype> prototypes;

    public PrototypeManager() {
    
    
        prototypes = new HashMap<>();
    }

    public void registerPrototype(String key, Prototype prototype) {
    
    
        prototypes.put(key, prototype);
    }

    public Prototype getPrototype(String key) {
    
    
        Prototype prototype = prototypes.get(key);
        if (prototype != null) {
    
    
            return prototype.clone();
        }
        return null;
    }
}

// 客户端
public class Main {
    
    
    public static void main(String[] args) {
    
    
        PrototypeManager manager = new PrototypeManager();
        manager.registerPrototype("A", new ConcretePrototypeA("Prototype A"));
        manager.registerPrototype("B", new ConcretePrototypeB(10));

        Prototype prototypeA = manager.getPrototype("A");
        if (prototypeA != null) {
    
    
            System.out.println("Clone A: " + ((ConcretePrototypeA) prototypeA).getName());
        }

        Prototype prototypeB = manager.getPrototype("B");
        if (prototypeB != null) {
    
    
            System.out.println("Clone B: " + ((ConcretePrototypeB) prototypeB).getNumber());
        }
    }
}

2. Implémentation d'un modèle prototype de modèle singleton paresseux

• Le modèle prototype du modèle singleton paresseux :
  Le modèle singleton paresseux est un moyen courant d'implémenter le modèle singleton, qui retarde l'instanciation de l'objet singleton jusqu'à ce qu'il soit créé pour la première fois. La combinaison du modèle paresseux singleton avec le modèle prototype peut obtenir un modèle de chargement paresseux et de réutilisation des instances.

Dans cette variante du modèle prototype, l'objet singleton fait office d'objet prototype et lorsque le client demande pour la première fois une instance, une copie de l'objet est obtenue par clonage et renvoyée en tant qu'objet singleton. Après cela, chaque requête renverra cette copie existante, évitant ainsi les processus de création et d'initialisation répétés.

Cette méthode d'implémentation combine le chargement différé et la réutilisation d'objets, et peut créer dynamiquement de nouveaux objets et les mettre en cache si nécessaire, améliorant ainsi les performances du système et l'utilisation des ressources.

• Implémentation du code de modèle de prototype du modèle singleton paresseux :

// 单例类
class Singleton {
    
    
    private static Singleton instance;

    // 私有构造函数
    private Singleton() {
    
    
        System.out.println("Singleton instance created.");
    }

    // 获取单例对象
    public static Singleton getInstance() {
    
    
        if (instance == null) {
    
    
            synchronized (Singleton.class) {
    
    
                if (instance == null) {
    
    
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    // 克隆方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
    
    
        throw new CloneNotSupportedException("Cannot clone a singleton object.");
    }
}

// 客户端
public class Main {
    
    
    public static void main(String[] args) {
    
    
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println("Singleton 1: " + singleton1);
        System.out.println("Singleton 2: " + singleton2);

        // 尝试克隆单例对象
        try {
    
    
            Singleton clone = (Singleton) singleton1.clone();
            System.out.println("Clone: " + clone);
        } catch (CloneNotSupportedException e) {
    
    
            System.out.println(e.getMessage());
        }
    }
}

3. Mode prototype à granularité fine

• Modèle de prototype à grain fin :
  le modèle de prototype à grain fin fait référence à la division d'un objet complexe en plusieurs parties et à la création d'objets prototypes correspondants pour chaque partie. De cette façon, lorsque vous devez utiliser une certaine pièce, il vous suffit de cloner l'objet prototype de cette pièce, au lieu de cloner l'intégralité de l'objet complexe.

Les modèles de prototypage à granularité fine peuvent améliorer la flexibilité et l’efficacité du système. Il permet au client de sélectionner les parties requises pour le clonage sans cloner l'objet entier. Dans le même temps, lorsqu'une certaine partie change, seul l'objet prototype correspondant doit être modifié au lieu de recréer l'objet entier.

Ce modèle convient aux objets complexes composés de plusieurs composants ou modules. Grâce à des objets prototypes à granularité fine, les composants d'objets complexes peuvent être construits et modifiés de manière plus flexible, réduisant ainsi la duplication et le couplage de code.

• Code de modèle de prototype à grain fin

// 原型接口
interface Prototype {
    
    
    Prototype clone();
}

// 具体原型类 A
class ConcretePrototypeA implements Prototype {
    
    
    private String name;

    public ConcretePrototypeA(String name) {
    
    
        this.name = name;
    }

    public String getName() {
    
    
        return name;
    }

    @Override
    public Prototype clone() {
    
    
        return new ConcretePrototypeA(this.name);
    }
}

// 具体原型类 B
class ConcretePrototypeB implements Prototype {
    
    
    private int number;

    public ConcretePrototypeB(int number) {
    
    
        this.number = number;
    }

    public int getNumber() {
    
    
        return number;
    }

    @Override
    public Prototype clone() {
    
    
        return new ConcretePrototypeB(this.number);
    }
}

// 客户端
public class Main {
    
    
    public static void main(String[] args) {
    
    
        Prototype prototypeA = new ConcretePrototypeA("Prototype A");
        Prototype cloneA = prototypeA.clone();
        if (cloneA instanceof ConcretePrototypeA) {
    
    
            System.out.println("Clone A: " + ((ConcretePrototypeA) cloneA).getName());
        }

        Prototype prototypeB = new ConcretePrototypeB(10);
        Prototype cloneB = prototypeB.clone();
        if (cloneB instanceof ConcretePrototypeB) {
    
    
            System.out.println("Clone B: " + ((ConcretePrototypeB) cloneB).getNumber());
        }
    }
}

Résumer

• Résumé de l'utilisation du mode prototype
• L'importance du modèle de prototype pour le développement de logiciels

// 抽象原型类
abstract class Prototype implements Cloneable {
    
    
    public abstract Prototype clone();
}

// 具体原型类
class ConcretePrototype extends Prototype {
    
    
    @Override
    public Prototype clone() {
    
    
        try {
    
    
            return (Prototype) super.clone();
        } catch (CloneNotSupportedException e) {
    
    
            e.printStackTrace();
            return null;
        }
    }
}

// 客户端
public class Client {
    
    
    public static void main(String[] args) {
    
    
        ConcretePrototype prototype = new ConcretePrototype();
        ConcretePrototype clone = (ConcretePrototype) prototype.clone();
        // 进行操作
    }
}

Le code ci-dessus montre une implémentation simple du modèle prototype, dans lequel la classe prototype abstraite définit un clone de méthode abstraite, qui est implémenté dans la classe prototype concrète, et l'objet est cloné en appelant la méthode super.clone(). Dans le client, vous pouvez créer un objet prototype et le cloner pour obtenir un nouvel objet à exploiter.

Le mode prototype convient aux scénarios dans lesquels un grand nombre d'objets similaires doivent être créés, et l'efficacité peut être améliorée en clonant des objets existants. Il simplifie le processus de création d'objets et réduit les opérations d'initialisation répétées. Dans le même temps, le mode prototype présente également une bonne évolutivité et une logique de clonage personnalisée peut être implémentée en héritant et en remplaçant la méthode de clonage.

En général, le modèle de prototype est un modèle de conception simple et pratique qui a une grande valeur d'application dans le développement de logiciels. En utilisant rationnellement le modèle de prototype, la réutilisabilité, la maintenabilité et la flexibilité du code peuvent être améliorées, améliorant ainsi l'efficacité et la qualité du développement logiciel.