1.原型模式的定义及使用场景
定义：
用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象
使用场景：
类初始化需要消耗非常多的资源，这个资源包括数据、硬件资源等，通过原型拷贝避免这些消耗
通过new产生一个对象需要非常繁琐的数据准备或访问权限，这时可以使用原型模式
一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝

Paste_Image.png

2.原型模式的优缺点

2.1优点

性能优良原型模式是在内存二进制流的拷贝，要比直接new一个对象性能好，特别是要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点

2.2缺点

逃避构造函数的约束这既是他的优点也是缺点，直接在内存中拷贝，构造函数不会执行。需要在实际应用时考虑

3.注意实现

构造函数默认不执行

浅拷贝及深拷贝

Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原型对象的内部元素地址，这种拷贝为浅拷贝。如需要深拷贝，对应的成员也需指向clone方法

要使用clone方法，类的成员变量上不要增加final关键字

4.原型模式的实现方式

ProtoType：

public class ProtoType implements Cloneable {  
  
  
    public ProtoType() {  
        System.out.println("ProtoType is excute...");  
    }  
  
  
    private int id;  
    private String name;  
  
  
    public int getId() {  
        return id;  
    }  
  
  
    public void setId(int id) {  
        this.id = id;  
    }  
  
  
    public String getName() {  
        return name;  
    }  
  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
  
    @Override  
    protected ProtoType clone() {  
        ProtoType protoType = null;  
        try {  
            protoType = (ProtoType) super.clone();  
        } catch (CloneNotSupportedException e) {  
            e.printStackTrace();  
        }  
        return protoType;  
    }  
  
  
    @Override  
    public String toString() {  
        return "ProtoType{" +  
                "id=" + id +  
                ", name='" + name + '\'' +  
                '}';  
    }  
}```
Text:

public class Test {

public static void main(String args[]) {  
    ProtoType type = new ProtoType();  
    type.setId(1);  
    type.setName("张三");  
    System.out.println(type);  
    ProtoType clone = type.clone();  
    clone.setId(2);  
    clone.setName("李四");  
    System.out.println(clone);  
}  

}“`
Objec的clone源码：

/** 
* Creates and returns a copy of this {@code Object}. The default 
* implementation returns a so-called "shallow" copy: It creates a new 
* instance of the same class and then copies the field values (including 
* object references) from this instance to the new instance. A "deep" copy, 
* in contrast, would also recursively clone nested objects. A subclass that 
* needs to implement this kind of cloning should call {@code super.clone()} 
* to create the new instance and then create deep copies of the nested, 
* mutable objects. 
* 
* @return a copy of this object. 
* @throws CloneNotSupportedException 
* if this object's class does not implement the {@code 
* Cloneable} interface. 
*/  
protected Object clone() throws CloneNotSupportedException {  
if (!(this instanceof Cloneable)) {  
throw new CloneNotSupportedException("Class " + getClass().getName() +  
" doesn't implement Cloneable");  
}  
return internalClone();  
}  
/* 
* Native helper method for cloning. 
*/  
private native Object internalClone();```
可见执行了一个native方法执行二进制流的拷贝
**5.原型模式在Android中的实际应用**
Intent：

@Override
public Object clone() {
return new Intent(this);
}

/**

• Copy constructor.
  */
  public Intent(Intent o) {
  this.mAction = o.mAction;
  this.mData = o.mData;
  this.mType = o.mType;
  this.mPackage = o.mPackage;
  this.mComponent = o.mComponent;
  this.mFlags = o.mFlags;
  this.mContentUserHint = o.mContentUserHint;
  if (o.mCategories != null) {
  this.mCategories = new ArraySet<String>(o.mCategories);
  }
  if (o.mExtras != null) {
  this.mExtras = new Bundle(o.mExtras);
  }
  if (o.mSourceBounds != null) {
  this.mSourceBounds = new Rect(o.mSourceBounds);
  }
  if (o.mSelector != null) {
  this.mSelector = new Intent(o.mSelector);
  }
  if (o.mClipData != null) {
  this.mClipData = new ClipData(o.mClipData);
  }
  }“`
  出处：http://huangjunbin.com/page/2/