原型模式 - 图2

什么是原型模式？what

原型模式：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
应用实例： 1、细胞分裂。 2、JAVA 中的 Object clone() 方法。
优点： 1、性能提高。 2、逃避构造函数的约束。
缺点： 1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 2、必须实现 Cloneable 接口。
**

怎么实现原型模式？how

添加一个抽象的原型类 Shape 实现Cloneable接口

  2. public abstract class Shape implements Cloneable{
  4.     private String id;
  5.     private String type;
  6.     abstract void draw();
  8.     public String getType() {
  9.         return type;
  10.     }
  12.     public String getId(){
  13.         return id;
  14.     }
  16.     public void setId(String id){
  17.         this.id = id;
  18.     }
  19.     public void setType(String type){
  20.         this.type = type;
  21.     }
  23.     public Object clone(){
  24.         Object obj = null;
  25.         try {
  26.             obj = super.clone();
  27.         }catch (CloneNotSupportedException e){
  28.             e.printStackTrace();
  29.         }
  30.         return obj;
  31.     }
  32. }

具体实现抽象方法的实体类 ：Circle 圆 、Square 方

  1. public class Circle extends Shape {
  3.     public Circle(){
  4.         setType("Circle");
  5.     }
  7.     @Override
  8.     void draw() {
  9.         System.out.println("draw "+getType());
  10.     }
  11. }
  1. public class Square extends Shape {
  3.     public Square(){
  4.         setType("Square");
  5.     }
  7.     @Override
  8.     void draw() {
  9.         System.out.println("draw "+getType());
  10.     }
  11. }

原型具体实现：需要提前加载好实现类Circle 圆 、Square 方 ，获取的时候只需要获取对应的克隆对象；

  1. public class ShapeCache {
  3.     private  Hashtable<String,Shape> shapeMap = new Hashtable<>();
  5.     public  Shape getShape(String shapeId){
  6.         return (Shape) shapeMap.get(shapeId).clone();
  7.     }
  9.     private ShapeCache(){
  10.         loadCache();
  11.     }
  13.     // 静态内部类
  14.     private static class SingletonHolder{
  15.         private static final ShapeCache instance = new ShapeCache();
  16.     }
  18.     public static ShapeCache getInstance(){
  19.         return SingletonHolder.instance;
  20.     }
  22.     //系统初始化时先加载
  23.     private void loadCache(){
  24.         System.out.println("加载预先设置好的类");
  25.         Circle c = new Circle();
  26.         c.setId("1");
  27.         shapeMap.put(c.getId(),c);
  29.         Square s = new Square();
  30.         s.setId("2");
  31.         shapeMap.put(s.getId(),s);
  32.     }
  33. }

测试原型方法

  1. public static void main(String[] args) {
  2.         Shape c = ShapeCache.getInstance().getShape("1");
  3.         Shape s = ShapeCache.getInstance().getShape("2");
  4.         c.draw();
  5.         s.draw();
  6.         s.setType("222");
  7.         s.draw();
  8.         Shape s2 = ShapeCache.getInstance().getShape("2");
  9.         s2.draw();
  10.     }

结果

  1. 加载预先设置好的类
  2. draw Circle
  3. draw Square
  4. draw 222
  5. draw Square

为什么使用原型模式？why

使用场景： 1、资源优化场景。 2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。 3、性能和安全要求的场景。 4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。 5、一个对象多个修改者的场景。 6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。 7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。

如果实例化一个类需要进行io读写，以及一些其他耗时的操作时可以用原型，节省类初始化时间；