Design Mode - Create a schema of the prototype model (b)

The definition and characteristics of prototype models

　　Prototype defined (the Prototype) mode are as follows: with an already created instance as a prototype to create a prototype of the same or similar new objects by copying this prototype object. Here, a prototypical instance specifies the kind of object to be created. Objects created in this way is very efficient, there is no need to know the details of object creation. For example, Windows operating system installation usually more time-consuming, if you copy a lot faster. Examples of replication in life very much, do not list them here.

Architecture and Implementation Mode Prototype

　　Because Java provides a clone objects () method, it is implemented in Java prototype model is very simple.

1. Structure Model

　　Prototype model consists of the following major role.

1. Abstract prototype class: specifies the interface must implement specific prototype object.
2. DETAILED class prototype: Prototype abstract class implement the clone () method, which is copied object.
3. Access classes: using clone () method of class specific prototype to copy the new object.

　　The structure shown in Figure 1.

Prototype model of the structure of FIG.

　　　　　　　　　　　　　　　　　　　　　　　　1 prototype pattern configuration diagram of FIG.

2. Mode of realization

　　Prototype model into a shallow clone and a deep clone clone, Java Object class provides the shallow clone of the clone () method, the prototype class can implement specific Cloneable interface object can be achieved shallow clone, here Cloneable interface is an abstract class prototype . Code is as follows:

// specific prototype class
class Realizetype implements Cloneable{
　　Realizetype () {
　　　　System the .out . Println ( "specific prototype created successfully!" );
　　}
　　public Object clone() throws CloneNotSupportedException{
　　　　System the .out . Println ( "specific prototype copy success!" );
　　　　return (Realizetype)super.clone();
　　}
}
　　// prototype model of the test class
public class PrototypeTest{
　　public static void main(String[] args)throws CloneNotSupportedException{
　　　　Realizetype obj1=new Realizetype();
　　　　Realizetype obj2=(Realizetype)obj1.clone();
　　　　System.out.println("obj1==obj2?"+(obj1==obj2));
　　}
}

　　Operating results of the program are as follows:

Specific prototyping success! 
Specific prototype replicate success! 
obj1 == obj2? false

Prototype Model Application Examples

　　[Example 1] using a prototype simulation mode "Monkey" replicate itself.

　　　　Analysis: Unplug the Monkey King monkey hair blowing gently becomes a lot Monkey King, which is actually used in the prototype model. Here Monkey class prototype SunWukong concrete classes, and Java in Cloneable interface is an abstract class prototype.

　　　　Like Pig example described earlier, due to the display image Monkey King ( Click here to download Monkey the image of the program to be displayed ), so that the Monkey class defined panel JPanel subclass, which contains a label, for storing Monkey Image.

　　　　Further, rewrite clone Cloneable interface () method for replicating new Monkey. Access classes can be copied a plurality of Monkey Monkey by calling clone () method, and displayed in a frame form JFrame. Figure 2 is a structural view.

　　　　　　　　　　　　　　　　　　　　　　FIG 2 is a configuration diagram generator Monkey

Code is as follows:

import java.awt.*;
import javax.swing.*;
class SunWukong extends JPanel implements Cloneable{
　　private static final long serialVersionUID = 5543049531872119328L;
　　public SunWukong () {
　　　　JLabel l1=new JLabel(new ImageIcon("src/Wukong.jpg"));
　　　　this.add(l1);
　　}
　　public Object clone(){
　　　　SunWukong W = null ;
　　　　try{
　　　　　　W = (SunWukong ) Super . clone ();
　　　　}
catch(CloneNotSupportedException e){
System the .out . Println ( "Wukong copy failed!" );
}
return w;
}
}
public class ProtoTypeWukong{
　　public static void main(String[] args){
　　　　The JFrame JF = new new the JFrame ( "Prototype Test Mode" );
　　　　jf.setLayout(new GridLayout(1,2));
　　　　Container contentPane=jf.getContentPane();
　　　　SunWukong OBJ1 = new new SunWukong ();
　　　　contentPane.add(obj1);
　　　　SunWukong obj2 = (SunWukong ) OBJ1 . Clone ();
　　　　contentPane.add(obj2);
　　　　jf . Pack ();
　　　　jf.setVisible(true);
　　　　jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
　　}
}

Running result of the program shown in Figure 3.

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　Run Results FIG.'S 3 Cloning Monkey

　　用原型模式除了可以生成相同的对象，还可以生成相似的对象，请看以下实例。

　　【例2】用原型模式生成“三好学生”奖状。

　　　　分析：同一学校的“三好学生”奖状除了获奖人姓名不同，其他都相同，属于相似对象的复制，同样可以用原型模式创建，然后再做简单修改就可以了。图 4 所示是三好学生奖状生成器的结构图。

　　　　　　　　　　　　　　　　　　　　　　　　　　图4 奖状生成器的结构图

程序代码如下：

public class ProtoTypeCitation{
　　public static void main(String[] args) throws CloneNotSupportedException{
　　　　citation obj1=new citation("张三","同学：在2016学年第一学期中表现优秀，被评为三好学生。","韶关学院");
　　　　obj1.display();
　　　　citation obj2=(citation) obj1.clone();
　　　　obj2.setName("李四");
　　　　obj2.display();
　　}
}
//奖状类
class citation implements Cloneable{
　　String name;
　　String info;
　　String college;
　　citation(String name,String info,String college){
　　　　this.name=name;
　　　　this.info=info;
　　　　this.college=college;
　　System.out.println("奖状创建成功！");
　　}
　　void setName(String name){
　　　　this.name=name;
　　}
　　String getName(){
　　　　return(this.name);
　　}
　　void display(){
　　　　System.out.println(name+info+college);
　　}
　　public Object clone() throws CloneNotSupportedException{
　　　　System.out.println("奖状拷贝成功！");
　　　　return (citation)super.clone();
　　}
}

　　程序运行结果如下：

奖状创建成功！
张三同学：在2016学年第一学期中表现优秀，被评为三好学生。韶关学院
奖状拷贝成功！
李四同学：在2016学年第一学期中表现优秀，被评为三好学生。韶关学院

原型模式的应用场景

　　原型模式通常适用于以下场景。

- 对象之间相同或相似，即只是个别的几个属性不同的时候。
- 对象的创建过程比较麻烦，但复制比较简单的时候。

原型模式的扩展

　　原型模式可扩展为带原型管理器的原型模式，它在原型模式的基础上增加了一个原型管理器 PrototypeManager 类。该类用 HashMap 保存多个复制的原型，Client 类可以通过管理器的 get(String id) 方法从中获取复制的原型。其结构图如图 5 所示。
　　

Prototype pattern configuration diagram of a prototype band manager

　　　　　　　　　　　　　　　　　　　　　　图5 带原型管理器的原型模式的结构图

　　【例3】用带原型管理器的原型模式来生成包含“圆”和“正方形”等图形的原型，并计算其面积。分析：本实例中由于存在不同的图形类，例如，“圆”和“正方形”，它们计算面积的方法不一样，所以需要用一个原型管理器来管理它们，图 6 所示是其结构图。
　　

　　　　　　　　　　　　　　　　　　　　　　　　　　图6 图形生成器的结构图

程序代码如下：

import java.util.*;
interface Shape extends Cloneable{
　　public Object clone(); //拷贝
　　public void countArea(); //计算面积
　　}
class Circle implements Shape{
　　public Object clone(){
　　　　Circle w=null;
　　　　try{
　　　　　　w=(Circle)super.clone();
　　　　}
　　　　catch(CloneNotSupportedException e){
　　　　　　System.out.println("拷贝圆失败!");
　　　　}
　　return w;
　　}
public void countArea(){
　　int r=0;
　　System.out.print("这是一个圆，请输入圆的半径：");
　　Scanner input=new Scanner(System.in);
　　r=input.nextInt();
　　System.out.println("该圆的面积="+3.1415*r*r+"\n");
　　}
}
class Square implements Shape{
　　public Object clone(){
　　Square b=null;
　　try{
　　　　b=(Square)super.clone();
　　}
　　catch(CloneNotSupportedException e){
　　　　System.out.println("拷贝正方形失败!");
　　}
　　return b;
}
public void countArea(){
　　int a=0;
　　System.out.print("这是一个正方形，请输入它的边长：");
　　Scanner input=new Scanner(System.in);
　　a=input.nextInt();
　　System.out.println("该正方形的面积="+a*a+"\n");
　　}
}
class ProtoTypeManager{
　　private HashMap<String, Shape>ht=new HashMap<String,Shape>();
　　public ProtoTypeManager(){
　　ht.put("Circle",new Circle());
　　ht.put("Square",new Square());
　　}
　　public void addshape(String key,Shape obj){
　　ht.put(key,obj);
　　}
　　public Shape getShape(String key){
　　Shape temp=ht.get(key);
　　return (Shape) temp.clone();
　　}
}
public class ProtoTypeShape{
　　public static void main(String[] args){
　　　　ProtoTypeManager pm=new ProtoTypeManager();
　　　　Shape obj1=(Circle)pm.getShape("Circle");
　　　　obj1.countArea();
　　　　Shape obj2=(Shape)pm.getShape("Square");
　　　　obj2.countArea();
　　}
}

Run results are shown below:

This is a circular, enter the radius of the circle: 3 
area of the circle = 28.2735 

This is a square, enter its side length: 3 
area of the square = 9