设计模式-原型模式

原型模式也属于创造型设计模式，他是通过复制一个已经存在的对象实例而得到一个新的实例，避免繁琐的实例化过程。在这里被复制的对象实例叫做原型，复制原型也叫克隆对象，有深克隆和浅克隆两种。

浅克隆

对值类型的成员变量进行值的复制,对引用类型的成员变量只复制引用,不复制引用的对象；也就是值类型和引用进行复制

深克隆

在浅克隆的基础上，对引用类型也进行克隆，而不仅仅是引用

原型克隆的 UML 类图如下：

client:提出创建对象请求；
propotype：抽象原型，给出所有具体原型需要实现的接口；
concretePropotype：具体的原型对象，需要被复制的对象；

仍然加以代码实现
先来浅拷贝,抽象原型

public interface Prototype  extends Cloneable {
 public Object clone() ;
}

//具体克隆对象
public class ConcretePropotype implements Propotype {

    private String name;
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

客户端测试下

public class Client {

    public static void main(String[] args) {
        ConcretePropotype propotype=new ConcretePropotype();
        propotype.setName("zhangsan");
        propotype.setAge(11);
        
        ConcretePropotype propotypeClone=(ConcretePropotype) propotype.clone();
        System.out.println(propotypeClone.getName());
        
        propotypeClone.setName("lisi");
        propotypeClone.setAge(12);
        
        System.out.println(propotype.getAge());
        System.out.println(propotypeClone.getName());
    }

}

这个属于浅克隆，没有涉及到引用类型，为了验证下，继续引入一个对象Student

public class Student {

    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

这里具体原型对象增加引入，代码为：

public class ConcretePropotype2 implements Propotype {

    private String name;
    private int age;
    private Student student;

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

进入 Client 端进行验证一下

public class Client2 {

    public static void main(String[] args) {
        ConcretePropotype2 propotype=new ConcretePropotype2();
        Student stu=new Student();
        stu.setAge(50);
        stu.setName("东郭");
        propotype.setStudent(stu);
        
        ConcretePropotype2 propotypeClone=(ConcretePropotype2) propotype.clone();
        propotypeClone.getStudent().setName("西施");
        propotypeClone.getStudent().setAge(100);
        
        System.out.println("原型："+propotype.getStudent().getName());
        System.out.println("克隆后："+propotypeClone. getStudent().getName());
        
        System.out.println("原型："+propotype.getStudent().getAge());
        System.out.println("克隆后："+propotypeClone. getStudent().getAge());
    }

}

由于是浅克隆，只是引用复制了，所以克隆后把原来的对象也修改了，最后的结果是

原型：西施
克隆后：西施
原型：100
克隆后：100

这个情况就会出现很大问题，把原来的对象彻底修改了，这可是不想遇到的，此时，深克隆粉墨登场，来解决这个问题；但是为了深克隆，需要克隆的对象可序列化，之前的Student对象需要实现public class Student implements Serializable，这样在 clone 对象里面利用串行化来做深复制。

public Object deepClone(){
  try {
   ByteArrayOutputStream bo = new ByteArrayOutputStream();
   ObjectOutputStream oo = new ObjectOutputStream(bo);   
   oo.writeObject(this);   
   //将对象从流里面读出来
   ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
   ObjectInputStream oi = new ObjectInputStream(bi);
   return oi.readObject(); 
  } catch (IOException | ClassNotFoundException e) {
   e.printStackTrace();
   return null;
  }
 }

当然还可以逐个对象的引用进行复制，那样引用层次较浅还可以接受，太深的话操作性非常不好。还是建议利用串行化来做深复制。

深度克隆之后完全就是两个对象了，互相不干扰，但需要克隆的对象序列化。既然是从克隆出来的，所以依附就小多了，只要产品具有克隆方法就可以克隆一个新的自己出来，再加以演化，就可以很方便的造出不同级别的产品出来。唯一的难点就是何时何地增加克隆方法，以及不能克隆的属性加以transient标识。