modèle de Prototype

modèle de Prototype (Prototype Pattern) est utilisé pour créer un objet en double, tout en assurant la performance. Ce type de modèles de conception appartiennent create schema, qui fournit la meilleure façon de créer des objets.

Ce modèle est un prototype d'interface, qui est utilisé pour créer un clone de l'objet courant. Lorsque le coût direct de la création d'un objet est relativement grande, puis en utilisant ce modèle. Par exemple, un objet doit être créé après la base de données est une opération coûteuse. Nous pouvons mettre en cache l'objet la prochaine fois qu'une demande de retour à son clone, le temps nécessaire pour mettre à jour la base de données, afin de réduire les appels de base de données.

introduction

Intention: Le prototype utilisé pour créer des instances des types d'objets spécifiés, et créer de nouveaux objets en copiant le prototype.

Principalement pour résoudre: la création et la suppression de prototype lors de l' exécution.

Quand l'utiliser: 1, quand un système doit être indépendant de sa création de produits, la composition et la représentation.2, quand une instance de la classe doit être spécifiée au moment de l'exécution, par exemple, le chargement dynamique. 3, afin d'éviter de créer une hiérarchie de classes et de la hiérarchie des produits lorsque la classe d'usine parallèle. 4, quand une instance d'une classe peut avoir quelques combinaisons différentes de l'Etat en une seule fois. Mettre en place un nombre correspondant de prototypes et de les cloner peut être plus pratique que le manuel chaque fois avec l'état approprié de l'instance de la classe.

Comment résoudre: l'utilisation d'un objet prototype existant, et de produire rapidement l' objet prototype comme un exemple.

Code de la clé:1, pour obtenir une opération de clonage, JAVA héritage Cloneable, réécrire clone (), peut être utilisé dans MemberwiseClone classe .NET Object () pour réaliser l'objet de la façon dont la copie ou la sérialisation peu profonde pour obtenir une copie en profondeur. 2, le même modèle de prototype pour le couplage entre l'utilisateur et l'isolement type spécifique (type variable) entre l'objet de classe, il exige également que ces «type de variable" a une interface stable.

Exemples d'application: 1, la division cellulaire.2, JAVA dans la méthode Object clone ().

Avantages: 1, la performance est améliorée.2 échapper constructeur contrainte.

Inconvénients: 1, avec une méthode de clonage nécessite de prendre en considération la classe des fonctions, que la nouvelle classe est pas difficile, mais pour les classes existantes peuvent ne pas être très facile, surtout quand une référence de classe ne prend pas en charge la sérialisation d'objet indirect, ou une structure cyclique contenant une référence au temps.2, doit implémenter l'interface Cloneable. 3, éviter constructeur contrainte.

Scénarios d' utilisation:1, des scénarios d'optimisation des ressources. 2, initialisation de classe doivent digérer beaucoup de ressources, y compris les données sur les ressources, les ressources matérielles. 3, la performance et les exigences de la scène de sécurité. 4, en générant un nouvel objet nécessite une préparation ou d'accès aux données très fastidieux, vous pouvez utiliser le modèle de prototype. 5, une pluralité d'objets modifiés par scène. 6, un objet doit fournir un accès à d'autres objets, et chaque appelant peut avoir besoin de modifier sa valeur, pensez à utiliser un modèle de prototype pour plusieurs copies d'objets utilisés par l'appelant. 7, dans le projet actuel, le modèle prototype se produit rarement seul, et la méthode d'usine modèle apparaissent généralement ensemble, créer une méthode clone d'objet, puis à l'appelant par la méthode de l'usine. Et modèle prototype Java a été incorporé dans son intégralité, il peut facilement être utilisé à utiliser.

Remarque: Avec une classe instancier pour construire le nouvel objet est différent, modèle prototype est de générer un nouvel objet en copiant un objet existant.copie Shallow réaliser Cloneable, réécrire, une copie en profondeur est lu flux binaire en mettant en œuvre Serializable.

réalisation

Nous allons créer uneformede classe abstraite et étend la classe d'entités classeShape.L'étape suivante consiste à définir la classeShapeCache,la forme de ces objets sont stockés dans unetabledehachagedans et au moment de la requête pour revenir à leurs clones.

PrototypPatternDemo,nos classes de démonstration à l' aide de classeShapeCachepour obtenir l'objetShape.

Etape 1

Créer une classe abstraite qui implémente l'interfaceCLONABLE.

Shape.java

Forme public abstract class implémente Cloneable {
   
   id String privé;
   type String protégé;
   
   abstraite tirage void ();
   
   public String getType () {
      le type de retour;
   }
   
   public String getId () {
      retour id;
   }
   
   setId public void (String id) {
      this.id = id;
   }
   
   Public Object clone () {
      Object clone = null;
      try {
         clone = super.clone ();
      } Catch (CloneNotSupportedException e) {
         e.printStackTrace ();
      }
      retour clone;
   }
}

Etape 2

Créer des classes d'entités ci-dessus étend la classe abstraite.

Rectangle.java

public class Rectangle étend Shape {

   publique Rectangle () {
     type = "Rectangle";
   }

   @Override
   tirage public void () {
      ( "Méthode Inside Rectangle :: draw ().") System.out.println;
   }
}

Square.java

public class place étend Shape {

   publique Carré () {
     type = "Square";
   }

   @Override
   tirage public void () {
      ( "Méthode Inside Place :: draw ().") System.out.println;
   }
}

Circle.java

Cercle public class Shape {

   publique Cercle () {
     type = "Cercle";
   }

   @Override
   tirage public void () {
      ( "Méthode Inside Cercle :: draw ().") System.out.println;
   }
}

Etape 3

Créer une classe, obtenez des classes d'entités de la base de données, et les stocke dans unHashtabledans.

ShapeCache.java

import java.util.Hashtable;

public class ShapeCache {
	
   private static Hashtable <String, Forme> shapeMap 
      = Nouveau Hashtable <String, Forme> ();

   Forme statique publique getShape (String ShapeID) {
      Forme cachedShape = shapeMap.get (ShapeID);
      retour (Shape) cachedShape.clone ();
   }

   // Pour chaque requêtes de base de données de forme d'exécution, et de créer la forme // shapeMap.put (ShapeKey, forme);
   // Par exemple, nous voulons ajouter trois formes loadCache public static void () {
      Cercle cercle = new Circle ();
      circle.setId ( «1»);
      shapeMap.put (circle.getId (), cercle);

      Square = new Carré ();
      square.setId ( "2");
      shapeMap.put (square.getId (), carré);

      Rectangle rectangle = new Rectangle ();
      rectangle.setId ( "3");
      shapeMap.put (rectangle.getId (), rectangle);
   }
}

Etape 4

PrototypePatternDemoutiliser la classeShapeCachepour obtenir la forme du clone est stocké dansla Hashtable.

PrototypePatternDemo.java

public class PrototypePatternDemo {
   main (String [] args) {public static void
      ShapeCache.loadCache ();

      Forme clonedShape = (Shape) ShapeCache.getShape ( "1");
      System.out.println ( "Shape:" + clonedShape.getType ());		

      Forme clonedShape2 = (Shape) ShapeCache.getShape ( "2");
      System.out.println ( "Shape:" + clonedShape2.getType ());		

      Forme clonedShape3 = (Shape) ShapeCache.getShape ( "3");
      System.out.println ( "Shape:" + clonedShape3.getType ());		
   }
}

Etape 5

Vérifiez la sortie.

Forme: Cercle
Forme: Carré
Forme: Rectangle