Mode générateur
La définition est également appelée le modèle du générateur. Il peut abstraction du processus de construction d'objets complexes (catégories abstraits), de sorte que différentes méthodes de mise en œuvre de ce processus abstraites peuvent construire des objets avec différentes manifestations (attributs).
Lorsqu'un algorithme pour créer un objet complexe doit être indépendant des composants de cet objet, et le processus de construction doit permettre à l'objet construit d'avoir des représentations différentes. Nous pourrions envisager d'utiliser le mode Builder.
accomplir
1. Builder spécifie une interface abstraite pour chaque composant qui crée un objet de produit. Habituellement, il contient des méthodes abstraites qui créent et renvoient des produits, ou il peut s'agir d'une méthode concrète, mettant le processus de création dans la classe Concretebuilder.
2. Concretebuilder implémente l'interface du constructeur pour construire et assembler divers composants du produit.
3. Le directeur est chargé d'appeler le constructeur approprié pour former le produit. La classe du directeur ne dépend généralement pas de la classe de produits. La classe Builder interagit directement avec la classe Director.
4. Le produit représente un objet complexe à construire. ConcretéBuilder crée une représentation interne du produit et définit son processus d'assemblage.
/ ** "Product" * / class Pizza {private String Dough = ""; Sauce de chaîne privée = ""; Topping de chaîne privée = ""; public void setDough (String pâte) {this.dough = pâte; } public void setsauce (Sauce String) {this.sauce = sauce; } public void Settopping (String Topping) {this.topping = topping; }} '' / ** "Résumé Builder" * / '' Résumé Classe Pizzabuilder {Pizza Protected Pizza; Public Pizza getpizza () {return pizza; } public void createNewPizzaproduct () {pizza = new pizza (); } public abstract void builddough (); abstrait void Buildsauce (); Public Abstract Void BuildTopping (); } / ** "ConcreteBuilder" * / class hawaiianpizzabuilder étend Pizzabuilder {public void builddough () {pizza.setDough ("Cross"); } public void buildsauce () {pizza.setsAUce ("doux"); } public void buildTopping () {pizza.setTopping ("Ham + Pineapple"); }} / ** "ConcreteBuilder" * / class SpicyPizzabuilder étend Pizzabuilder {public void builddough () {pizza.setDough ("Pan cuit"); } public void buildsauce () {pizza.setsAUce ("hot"); } public void buildTopping () {pizza.setTopping ("pepperoni + salami"); }} '' / ** "Director" * / 'Class Waiter {Private Pizzabuilder Pizzabuilder; public void setPizzabuilder (pizzabuilder pb) {pizzabuilder = pb; } Public Pizza Getpizza () {return pizzabuilder.getpizza (); } public void ConstructPizza () {pizzabuilder.CreateEwPizzaproduct (); pizzabuilder.builddough (); pizzabuilder.buildsauce (); pizzabuilder.buildtopping (); }} / ** Un client commandant une pizza. * / class BuildErexample {public static void main (String [] args) {serveur serveur = new serveur (); Pizzabuilder hawaiian_pizzabuilder = new hawaiianpizzabuilder (); Pizzabuilder Spicy_Pizzabuilder = new SpicyPizzabuilder (); serveur.setpizzabuilder (hawaiian_pizzabuilder); serveur.constructpizza (); Pizza pizza = serveur.getpizza (); }}Le client crée l'objet Director et le configure avec l'objet Builder qu'il souhaite. Le directeur obtient la demande du client de créer le produit et obtient enfin le produit.
avantage
1. Le processus de construction d'objets peut être soigneusement contrôlé pour produire différents objets de produit.
2. Facile à se développer. Lorsqu'il y a un nouveau produit, vous pouvez simplement ajouter un nouveau Concretebuilder pour y parvenir.
Le modèle d'usine abstrait de motif connexe est similaire aux générateurs car il peut également créer des objets complexes. La principale différence est que le modèle du générateur se concentre sur la construction d'un objet complexe étape par étape. Le modèle d'usine abstrait se concentre sur plusieurs séries d'objets de produit (simple ou complexe).
Le générateur renvoie le produit dans la dernière étape, et pour l'usine abstraite, le produit revient immédiatement.
Mode prototype
La définition d'un motif de prototype est un type de modèle de création, qui se caractérise par la «copie» d'une instance existante pour renvoyer une nouvelle instance, plutôt que de créer une nouvelle instance. L'exemple copié est ce que nous appelons un "prototype", qui est personnalisable.
Le mode prototype est principalement utilisé pour créer des instances complexes ou longues, car dans ce cas, la copie d'une instance existante rend le programme plus efficace; ou créant des valeurs égales, nommant simplement différentes données similaires.
accomplir
1. Client - Créez un nouvel objet, puis obtenez un autre objet via le clone.
2. Prototype - Définissez la propre méthode abstraite d'un clone.
3. ConcretePrototype - Implémentez la méthode des clones.
Prototype d'interface publique {public abstrait objet clone (); } classe publique ConcretePrototype implémente le prototype {public objet clone () {return super.clone (); }} public class Client {public static void main (String arg []) {ConcretePrototype obj1 = new CONCRETEPROTOTYPE (); ConcretePrototype obj2 = concrèteprototype) obj1.clone (); }} Exemple
1. De nombreux éléments du jeu sont répétés, et nous pouvons utiliser le mode prototype pour copier les mêmes éléments.
2. Lors de la fabrication de cartes de données, la première fois, nous devons lire les données de la base de données et les enregistrer dans l'objet. Lorsque nous devons fabriquer d'autres graphiques des mêmes données, l'utilisation du mode prototype peut éviter de relire la base de données.
Questions et implémentations connexes
1. Si le nombre de prototypes à créer n'est pas fixe, vous pouvez créer un gestionnaire de prototypes. Avant de copier l'objet Prototype, le client vérifie d'abord s'il existe des objets prototypes qui remplissent les conditions du gestionnaire de prototypes. S'il y en a, il l'utilisera directement. Sinon, clone un. C'est ce qu'on appelle la forme d'enregistrement du mode prototype.
2. Il existe deux types de copie: copie profonde et copie superficielle. Lors de la copie, l'objet Copy et l'objet Prototype partagent toutes les variables internes de l'objet, et les deux objets ont le même espace mémoire et le même cycle de vie. La modification de l'objet prototype modifie également sa réplique et vice versa.
En Java, tant que vous implémentez l'interface clonable, vous pouvez appeler la méthode de clone de la classe d'objets pour réaliser une copie superficielle:
classe publique ShallowClone implémente clonable {int Age; Personne personne; public void Setage (int Age) {this.age = Âge; } public void SetPerson (nom de chaîne) {Person = new Person (nom); } public objet clone () lève ClonenotsupportException {// Le Java par défaut implémente la copie superficielle return super.clone (); }} Public Class Person {String Name; Personne publique (nom de chaîne) {this.name = name; }} Public Class Test {public static void main (String [] args) lève ClonenotsupporTedException {shallowclone oldshallowclone = new shallowclone (); OldShallowClone.Setage (20); OldShallowClone.SetPerson ("Eric"); System.out.println ("OldName:" + OldShallowClone.Person.Name + "Age:" + OldShallowClone.age); Shallowclone newshallowclone = (Shallowclone) oldshallowclone.clone (); System.out.println ("newname:" + newshallowclone.person.name + "Âge:" + newshallowclone.age); OldShallowclone.age = 30; Oldshallowclone.person.name = "Frank"; System.out.println ("newname:" + newshallowclone.person.name + "Âge:" + newshallowclone.age); }} Sortir:
Oldname: Eric Age: 20Newname: Eric Age: 20Newname: Frank Age: 20
On peut voir que la copie de l'objet est une référence à l'objet. Lorsque la valeur de l'objet est modifiée, l'objet copié change également et le type de base de Java est la valeur copiée.
Ci-dessous, nous mettons en œuvre une copie profonde:
classe publique Deepclone {int Age; Personne personne; public void Setage (int Age) {this.age = Âge; } public void SetPerson (nom de chaîne) {Person = new Person (nom); } public DeepClone (DeepClone DeepClone) {this.age = deepclone.age; this.person = new personne (deepclone.person.name); } public DeepClone () {} public Object Clone () lève ClonenotsupportEdException {return new DeepClone (this); }} Public Class Test {public static void main (String [] args) lève ClonenotsupporTedException {DeepClone olddeepClone = new DeepClone (); olddeepclone.setage (20); olddeepclone.setperson ("Eric"); System.out.println ("OldName:" + OlddeepClone.person.name + "Age:" + OlddeepClone.age); Deepclone newdeepClone = (DeepClone) olddeepclone.clone (); System.out.println ("newname:" + newdeepclone.person.name + "Âge:" + newdeepclone.age); olddeepclone.age = 30; olddeepclone.person.name = "Frank"; System.out.println ("newname:" + newdeepclone.person.name + "Âge:" + newdeepclone.age); }} Sortir:
Oldname: Eric Age: 20Newname: Eric Age: 20Newname: Eric Age: 20
Dans la méthode de copie ci-dessus, nous avons recréé un objet et recréé la référence pour mettre en œuvre une copie profonde.
avantage
1. La copie est meilleure que neuve.
2. Simplifier ou masquer les détails de la création d'objets et les copier directement.