原型模式也属于创造型设计模式，他是通过复制一个已经存在的对象实例而得到一个新的实例，避免繁琐的实例化过程。在这里被复制的对象实例叫做原型，复制原型也叫克隆对象，有深克隆和浅克隆两种。
浅克隆
对值类型的成员变量进行值的复制,对引用类型的成员变量只复制引用,不复制引用的对象；也就是值类型和引用进行复制
深克隆
在浅克隆的基础上，对引用类型也进行克隆，而不仅仅是引用
原型克隆的 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标识。
