Quel est le point du Prototype de modèle de conception?

Le Prototype de modèle est une création de modèle basé sur le clonage d'une pré-configuré objet. L'idée est que vous choisissez un objet qui est configuré par défaut ou dans le stade de quelques cas d'utilisation spécifiques et alors vous un clone de l'objet et de configurer exactement à vos besoins.

Le modèle est utile pour supprimer un tas de code réutilisable, lorsque la configuration requise serait onéreux. Je pense que de Prototypes en tant que préréglage de l'objet, où vous enregistrez un tas d'etat comme un nouveau point de départ.

Beaucoup d'autres réponses ici parler des économies de coûts de clonage déjà configuré objet, mais je voudrais élargir sur l'autre "point" du Prototype de modèle. Dans certaines langues, où les classes sont traitées comme des objets de première classe, vous pouvez configurer ce type d'objet est créée par un client au moment de l'exécution, en passant le nom de la classe. Dans des langages comme C++, où les classes ne sont pas traités comme des objets de première classe, le Prototype de modèle vous permet d'obtenir le même effet.

Par exemple, disons que nous avons un Chef dans un restaurant dont le travail consiste à préparer et servir les repas. Disons que le Chef est sous-payé et de mauvaise humeur, donc, il fait des plats comme le suivant:

class Chef {
    public:
        void prepareMeal() const {
            MozzarellaSticksWithKetchup* appetizer = new MozzarellaSticksWithKetchup();
            //do something with appetizer...

            HockeyPuckHamburgerWithSoggyFries* entree = new HockeyPuckHamburgerWithSoggyFries();
            //do something with entree...

            FreezerBurnedIceCream* dessert = new FreezerBurnedIceCream();
            //do something with dessert...
        }
};

Maintenant, disons que nous voulons changer le Chef être un ostentatoire, le célèbre chef. Cela signifie qu'il/elle a à new différents plats dans prepareMeal(). Nous tenons à modifier la méthode ainsi que les types de repas que se new par le Chef peut être spécifié en tant que paramètres. Dans d'autres langues où les classes sont des objets de première classe, on peut tout simplement passer à la classe des noms comme paramètres de la méthode. Nous ne pouvons pas faire cela en C++, afin que nous puissions bénéficier du prototype de modèle:

class Appetizer {
    public:
        virtual Appetizer* clone() const = 0;
        //...
};

class Entree {
    public:
        virtual Entree* clone() const = 0;
        //...
};

class Dessert {
    public:
        virtual Dessert* clone() const = 0;
        //...
};

class MozzarellaSticksWithKetchup : public Appetizer {
    public:
        virtual Appetizer* clone() const override { return new MozzarellaSticksWithKetchup(*this); }
        //...
};

class HockeyPuckHamburgerWithSoggyFries : public Entree {
    public:
        virtual Entree * clone() const override { return new HockeyPuckHamburgerWithSoggyFries(*this); }
        //...
};

class FreezerBurnedIceCream : public Dessert {
    public:
        virtual Dessert * clone() const override { return new FreezerBurnedIceCream(*this); }
        //...
};

//...and so on for any other derived Appetizers, Entrees, and Desserts.

class Chef {
    public:
        void prepareMeal(Appetizer* appetizer_prototype, Entree* entree_prototype, Dessert* dessert_prototype) const {
            Appetizer* appetizer = appetizer_prototype->clone();
            //do something with appetizer...

            Entree* entree = entree_prototype->clone();
            //do something with entree...

            Dessert* dessert = dessert_prototype->clone();
            //do something with dessert...
        }
};

Noter qu'un clone() méthode crée une instance du type dérivé, mais retourne un pointeur vers le type parent. Cela signifie que nous pouvons changer le type de l'objet qui vient d'être créé en utilisant un autre type dérivé, et le client ne sait pas la différence. Cette conception nous permet désormais de configurer un Chef -- le client de nos Prototypes -- pour fabriquer différents types de plats au moment de l'exécution:

Chef chef;

//The same underpaid chef from before:
MozzarellaSticksWithKetchup mozzarella_sticks;
HockeyPuckHamburgerWithSoggyFries hamburger;
FreezerBurnedIceCream ice_cream;
chef.prepareMeal(&mozzarella_sticks, &hamburger, &ice_cream);

//An ostentatious celebrity chef:
IranianBelugaCaviar caviar;
LobsterFrittataWithFarmFreshChives lobster;
GoldDustedChocolateCupcake cupcake;
chef.prepareMeal(&caviar, &lobster, &cupcake);

Vous demandez peut-être utilisé de cette façon, le Prototype de modèle vous permet d'acheter la même chose que la Méthode de modèle, alors pourquoi ne pas l'utiliser? Parce que la Méthode de modèle nécessiterait une hiérarchie de créateur classes qui reflètent la hiérarchie des produits en cours de création; c'est à dire nous aurions besoin d'un MozzarellaSticksWithKetchupCreator avec un make() méthode, un HockeyPuckHamburgerWithSoggyFriesCreator avec un make() méthode, et ainsi de suite. Ainsi, vous pouvez afficher le Prototype de modèle tout simplement comme un moyen de soulager le code de redondance est souvent présenté par la Méthode de motif.

Cet argument est tiré de Design Patterns: Elements de Logiciels Orientés Objets Réutilisables, une.k.un. le "Gang des Quatre" livre.

Par rapport à l'abstrait modèle de fabrique, en utilisant le prototype de modèle, vous n'avez pas à avoir une grande usine de hiérarchie, juste un grand produit de la hiérarchie.