En tant que matériel d'apprentissage des modèles de conception du GoF, le livre «Introduction aux modèles de conception appris dans le langage Java augmenté et révisé» semble être utile. Cependant, comme les exemples repris sont basés sur JAVA, j'ai essayé la même pratique avec Python pour approfondir ma compréhension.

■ Prototype (modèle de prototype)

Le modèle de prototype (modèle de prototype) est l'un des modèles de conception liés à la génération utilisés dans le développement de logiciels. Utilisé lorsque le type d'objet créé est une instance de prototype (typique), dupliquant ce prototype pour créer un nouvel objet.

Ce modèle est utilisé aux fins suivantes.

Évitez de sous-classer le créateur d'un objet dans une application cliente, comme cela est fait dans le modèle Abstract Factory
Évitez lorsque le coût inhérent à la création d'un nouvel objet de la manière standard (par exemple `` nouveau '') est trop élevé pour une application donnée

Pour implémenter ce modèle, déclarez une classe de base abstraite qui spécifie la méthode clone () de la méthode virtuelle pure. Toutes les classes qui nécessitent la capacité de "constructeurs polymorphes" dérivent elles-mêmes de classes de base abstraites et implémentent des opérations clone ().

UML class and sequence diagram UML class diagram

(Ce qui précède est cité sur Wikipedia)

□ Mémorandum

Le modèle Prototype consiste à créer une autre instance à partir d'une instance en copiant l'instance au lieu de créer une instance à partir de la classe. Les avantages de l'utilisation du modèle Prototype sont décrits à la page 66 du livre" Introduction aux modèles de conception appris dans le langage Java augmenté et révisé ". (1) Lorsqu'il y a trop de types à assembler dans une classe (2) Lorsqu'il est difficile de créer une instance à partir d'une classe (3) Lorsque vous souhaitez séparer le framework et l'instance générée

Eh bien, s'il y a des cas d'utilisation qui génèrent un grand nombre d'instances, cela conduira-t-il à une réduction des frais généraux liés à la création d'instances?

■ Exemple de programme "Prototype"

Je voudrais exécuter un exemple de programme qui utilise le modèle Prototype et vérifier le comportement suivant.

--Afficher la chaîne de caractères soulignée --Afficher la chaîne de caractères entourée d'une bordure

$ python Main.py 
"Hello World"
-------------

***************
* Hello World *
***************

///////////////
/ Hello World /
///////////////

■ Détails de l'exemple de programme

Un code similaire a été téléchargé dans le référentiel Git. https://github.com/ttsubo/study_of_design_pattern/tree/master/Prototype

Structure du répertoire

.
├── Main.py
└── framework
    ├── __init__.py
    ├── decoprototype
    │   ├── __init__.py
    │   ├── message_box_prototype.py
    │   └── underline_pen_prototype.py
    ├── manager.py
    └── prototype.py

(1) Le rôle du prototype

Le rôle Prototype définit l'interface de copie (duplication) d'une instance pour créer une nouvelle instance. Dans l'exemple de programme, la classe Prototype remplit ce rôle.

`framework/prototype.py`


from abc import ABCMeta, abstractmethod

class Prototype(metaclass=ABCMeta):
    @abstractmethod
    def use(self, s):
        pass

    @abstractmethod
    def createClone(self):
        pass

(2) Le rôle du prototype concret

Le rôle ConcretePrototype implémente en fait la méthode de copie d'une instance et de création d'une nouvelle. Dans l'exemple de programme, la classe ʻUnderlinePen et la classe MessageBox` remplissent ce rôle.

`framework/decoprototype/underline_pen_prototype.py`


import copy
from framework.prototype import Prototype

class UnderlinePen(Prototype):
    def __init__(self, ulchar):
        self.__ulchar = ulchar

    def use(self, s):
        length = len(s)
        line = self.__ulchar * (length + 2)

        print("\"{0}\"".format(s))
        print("{0}\n".format(line))

    def createClone(self):
        clone = copy.deepcopy(self)
        return clone

`framework/decoprototype/message_box_prototype.py`


import copy
from framework.prototype import Prototype

class MessageBox(Prototype):
    def __init__(self, decochar):
        self.__decochar = decochar

    def use(self, s):
        length = len(s)
        line = self.__decochar * (length + 4)

        print("{0}".format(line))
        print("{0} {1} {2}".format(self.__decochar, s, self.__decochar))
        print("{0}\n".format(line))

    def createClone(self):
        clone = copy.deepcopy(self)
        return clone

(3) Le rôle du client (utilisateur)

Le rôle Client crée une nouvelle instance en utilisant la méthode qui copie l'instance. Dans l'exemple de programme, la classe Manager et la méthode startMain remplissent ce rôle.

`framework/manager.py`


class Manager(object):
    def __init__(self):
        self.__showcase = {}

    def register(self, name, proto):
        self.__showcase[name] = proto

    def create(self, protoname):
        p = self.__showcase[protoname]
        return p.createClone()

`Main.py`


from framework.manager import Manager
from framework.decoprototype.underline_pen_prototype import UnderlinePen
from framework.decoprototype.message_box_prototype import MessageBox

def startMain(managerObject):
    upen = UnderlinePen("-")
    mbox = MessageBox("*")
    sbox = MessageBox("/")
    managerObject.register("strong message", upen)
    managerObject.register("warning box", mbox)
    managerObject.register("slash box", sbox)

    p1 = managerObject.create("strong message")
    p2 = managerObject.create("warning box")
    p3 = managerObject.create("slash box")
    p1.use("Hello World")
    p2.use("Hello World")
    p3.use("Hello World")

if __name__ == "__main__":
    startMain(Manager())

■ URL de référence

Finition "Introduction aux modèles de conception appris en langage Java" (non) Introduction aux modèles de conception appris dans Language-Finishing-No-2cc9b34a30b2)
Modèle de prototype du "journal de tachikawa844"

Apprenez le modèle de conception "Prototype" avec Python