文章结构-意义 -解决 - 关键代码-实例 -解释 -图解
意义：
原型模式是一种用于创建重复对象，同时又能保证性能的一种创建型模式，改方式实现了原型接口，并在需要的时候更新数据库，以此来减少数据库的调用，其核心意义用原型的实例创建对象的种类，并通过拷贝将这些原型创建新的对象了。
解决了：
主要解决了在运行期间建立和删除原型的操作
关键代码：
Java类在通过继承Cloneable 重写clone()，在.NET中可以使用Object类的MemberwiSeClone()方法来实现对象的浅拷贝，和序列化的深拷贝。 且原型模式同样用于隔离对象的使用者和具体类之间的耦合关系，利用clone()方法来实现克隆；
优点：
1、性能提高。 2、逃避构造函数的约束。
缺点：
1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 2、必须实现 Cloneable 接口。
实例
步骤一：创建一个实现了Cloneable的类，并且复写clone()调用，这样当该类或者该类的子类就可以调用clone()方法来克隆自己了
public abstract class Shape implements Cloneable {
private String id;
protected String type;
abstract void draw();
public String getType(){
return type;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}
步骤2：创建几个实体类 继承图形类并且实现对应的方法，同时写上构造器含参数type
public class Rectangle extends Shape {
public Rectangle(){
type = "Rectangle";
}
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
public class Square extends Shape {
public Square(){
type = "Square";
}
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
public class Circle extends Shape {
public Circle(){
type = "Circle";
}
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
步骤3：创建一个图形缓存，内部有一个shapeMap方法 key是String类型用于存Shape抽象类的id value是Shape是图形类 ， 还有一个方法getShape(shapeId) 传入指定指定的Shapeid 获取Shape对象，还有一个方法叫做localCache(); 其实是模仿了数据库的操作，向Map中缓存了三个带有id的Shape的子类的对象；
import java.util.Hashtable;
public class ShapeCache {
private static Hashtable<String, Shape> shapeMap
= new Hashtable<String, Shape>();
public static Shape getShape(String shapeId) {
Shape cachedShape = shapeMap.get(shapeId);
return (Shape) cachedShape.clone();
}
// 对每种形状都运行数据库查询，并创建该形状
// shapeMap.put(shapeKey, shape);
// 例如，我们要添加三种形状
public static void loadCache() {
Circle circle = new Circle();
circle.setId("1");
shapeMap.put(circle.getId(),circle);
Square square = new Square();
square.setId("2");
shapeMap.put(square.getId(),square);
Rectangle rectangle = new Rectangle();
rectangle.setId("3");
shapeMap.put(rectangle.getId(),rectangle);
}
}
步骤4：原型模式的Demo 也就是先调用了locaCache() 初始化缓存了ShapeCache的map 然后在通过ShaoeCache.getSahpe("1"); 获取了缓存在map里卖弄的Shape的子类的对象，并通过克隆方法进行返回
public class PrototypePatternDemo {
public static void main(String[] args) {
ShapeCache.loadCache();
Shape clonedShape = (Shape) ShapeCache.getShape("1");
System.out.println("Shape : " + clonedShape.getType());
Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
System.out.println("Shape : " + clonedShape2.getType());
Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
System.out.println("Shape : " + clonedShape3.getType());
}
}
解释： 其实就是隔离了对象创建的操作，当一个对象创建十分耗费性能时，那么可以将整个对象缓存起来，我们需要用的时候，克隆出来一个一样的（此时内存地址已经改变 若内部有字段类型未实现Cloneabel方法，可能会出现引用地址传递的问题，这样的话也就只是能实现浅拷贝如StringBuffer就会出现这种问题）
整个的流程就是 ShapeCache.loadCache(); 初始化缓存 -》 Shape clonedShape = (Shape) ShapeCache.getShape("1"); 获取指定的Shape子类的对象，然后进行克隆操作返回一个新的对象，但是该对象并不是new 的， System.out.println("Shape : " + clonedShape.getType()); 验证是否克隆成功
