Prototype Pattern en Java - la méthode clone ()

Donc, j'ai lu sur les Modèles de Conception et les Modèles de Prototypes me confond. Je crois que l'un des points de l'aide c'est d'éviter le besoin de l'aide de l' nouveau de l'opérateur. Puis je regarde cet exemple:

http://sourcemaking.com/design_patterns/prototype/java/1

Tout d'abord, Leur idée de Prototype met en œuvre une méthode clone (), ce qui est étrange. Wikipédia a également dit que j'ai besoin d'une méthode virtuelle pure clone pour être mis en œuvre par les sous-classes (pourquoi?). Ne pas Java fournissent déjà une telle méthode, en train de faire exactement ce que nous avons besoin de le faire (ce qui est de créer une copie d'un objet au lieu de l'instanciation à partir de zéro)? Deuxièmement, la méthode clone appelle l'opérateur nouveau! Sûrement l'exemple est mal? (Dans ce cas, je devrais être en train d'étudier des Modèles de Conception d'ailleurs, non?). Quelqu'un peut dire si cette correction fait-il le droit?:

static class Tom implements Cloneable implements Xyz {
    public Xyz    cloan()    {
      return Tom.clone(); //instead of new I use clone() from Interface Cloneable
    }
    public String toString() {
      return "ttt";
    }
  }

Tout clarification est apprécié.

source d'informationauteur Leandro Nogueira Couto | 2013-06-20

9

L'idée de prototype de modèle est d'avoir un plan ou un modèle à partir de laquelle vous pouvez lancer votre instance. Ce n'est pas simplement "d'éviter à l'aide de nouveau en Java"

Si vous mettez en œuvre un prototype de modèle en Java, alors oui, par tous les moyens de remplacer le clone() méthode de la classe d'Objet, pas besoin d'en créer un nouveau. (Également besoin de mettre en œuvre Clonable interface ou vous aurez exception)

Comme un exemple:
```
//Student class implements Clonable
Student rookieStudentPrototype = new Student();
rookieStudentPrototype.setStatus("Rookie");
rookieStudentPrototype.setYear(1);

//By using prototype pattern here we don't need to re-set status and
//year, only the name. Status and year already copied by clone
Student tom = rookieStudentPrototype.clone();
tom.setName("Tom");

Student sarah = rookieStudentPrototype.clone();
sarah.setName("Sarah");
```
3

Un modèle de conception est tout simplement une façon de représenter la façon dont le logiciel est écrit de manière reproductible. Il existe en fait différents syntaxiques approches pour obtenir la même chose.

Ainsi, le Prototype de modèle est tout simplement une approche qui utilise une copie principale de mettre en œuvre certaines primordial de la fonctionnalité. Il y a plusieurs façons de le faire en Java (ainsi, je crois que dans d'autres langues). En voici un qui utilise le "nouveau" mot-clé, et il est basé sur l'utilisation d'une interface comme un contrat avec la mise en œuvre de classes concrètes. Puis une seule méthode de la mise en œuvre concrète de l'interface et effectue la même opération:
```
//software contract
interface Shape { 
   public void draw();
} 
//concrete implementations
class Line implements Shape {
   public void draw() {
      System.out.println("line");
   }
}
class Square implements Shape {
   public void draw() {
      System.out.println("square");
   }
}
...
class Painting {
   public static void main (String[] args) {
      Shape s1 = new Line ();
      Shape s2 = new Square ();
      ...
      paint (s1);
      paint (s2);
      ...
   }
   //single method executes against the software contract as a prototype
   static void paint (Shape s) {
      s.draw ();
   }
}
```
Vous pouvez en lire plus à http://www.javacamp.org/designPattern/prototype.html ou consultez le principal Motif de Conception de site. Les informations y sont présentées complet avec références.
3

L'exemple que vous avez lié est correct et votre code
```
return Tom.clone();
```
ne compile pas car clone() n'est pas une méthode statique.

Le clonage n'est pas sur la manière d'éviter l'utilisation de new de l'opérateur, mais la création d'une nouvelle instance qui a le même état (valeurs de ses champs des membres) que celui de l'objet qui est en cours de duplication. Par conséquent, clone() est pas statique, mais une méthode d'instance, de sorte que vous pouvez créer une nouvelle instance (et à l'aide de nouveau n'est pas un problème) qui reflète l'état de l'objet que clone() a été invoqué sur.

C'est juste que votre exemple des classes (comme Tom) sont tellement simples (sans état) que tout ce que le clone() méthode est en train de faire est d'instancier un nouveau instance. Si elle avait un peu plus complexe de l'état (dire un ArrayList d'objets) le clone() méthode aurait à faire une copie en profondeur de la ArrayList.

Pour élaborer avec l'un de vos exemple des classes, supposons que Tom eu quelques l'état de l'instance. Maintenant, la clone() devra également s'assurer que la copie étant renvoyé correspond à l'état de l'actuel.
```
static class Tom implements Xyz {

    private String name;

    public Tom() {
      this.name = "Tom"; //some state
    }

    public Xyz clone()    {
      Tom t = new Tom();
      t.setName(getName()); //copy current state
      return t;
    }

   public String toString() {
      return getName();
    }

   public String getName() {
      return name;
    }

   public void setName(String name) {
      this.name = name;
    }
}
```
0

Vous pouvez également utiliser BeanUtils.copyProperties méthode pour faire la même chose qui est fourni par le framework Spring org.springframework.les haricots.BeanUtils;

Vous devez vous connecter pour publier un commentaire.