1.前言
单例模式可以避免重复创建消耗资源的对象，但是却不得不共用对象。若是对象本身也不让随意访问修改时，怎么办？通常做法是备份到副本，其它对象操作副本，最后获取权限合并，类似git上的PR操作。
2.概念
原型模式用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。需要注意的关键字是，新的对象，类没变。Java正好提供了Cloneable接口，它标识的类可以调用Object中实现的clone()方法而不抛出异常，即运行时通知虚拟机可以安全使用clone()方法返回拷贝对象。由于它直接操作内存中的二进制流，当大量操作或操作复杂对象时，性能优势将会很明显。
3.场景
动物园中有一只羊，对它进行克隆，产生另外一只完全一样的羊，分别安排两位有孩子的管理员照顾。有一天，对克隆羊进行基因操作，观察变化。
4.写法
// 1.声明此类可以被clone
public class Sheep implements Cloneable {
private int age;
private String sex;
private Admin admin;
public Sheep(int age, String sex, Admin admin) {
super();
this.age = age;
this.sex = sex;
this.admin = admin;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Admin getAdmin() {
return admin;
}
public void setAdmin(Admin admin) {
this.admin = admin;
}
@Override
public String toString() {
return "Sheep [age=" + age + ", sex=" + sex + ", admin=" + admin + "]";
}
// 2.调用Object的clone方法
public Sheep startClone() {
Sheep sheep = null;
try {
sheep = (Sheep) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return sheep;
}
}
public class Admin {
private int age;
private String sex;
private Child child;
public Admin(int age, String sex, Child child) {
super();
this.age = age;
this.sex = sex;
this.child = child;
}
public void setAge(int age) {
this.age = age;
}
public void setSex(String sex) {
this.sex = sex;
}
public void setChild(Child child) {
this.child = child;
}
@Override
public String toString() {
return "Admin [age=" + age + ", sex=" + sex + ", child=" + child + "]";
}
}
public class Child {
}
public class Zoo {
public static void main(String[] args) {
Sheep old = new Sheep(2, "雄性", new Admin(25, "女", new Child()));
System.out.println(old.toString());
Sheep current = old.startClone();
System.out.println(current.toString());
// 对克隆羊做处理
current.setAge(1);
current.setSex("雌性");
current.getAdmin().setAge(34);
current.getAdmin().setSex("男");
System.out.println(old.toString());
System.out.println(current.toString());
}
}
根据上面的代码，我们知道羊引用了管理员，管理员引用了孩子。当对内存中数据拷贝时，除了基本数据类型（包括封装类型）及String类型，其它的引用关系将直接传递给副本，并不是重新创建一个对象。所以当对克隆羊操作时，年龄和性别直接改变，而对管理员的操作将寻址到内存中对应部分进行修改，导致原型也被修改。孩子与管理员的关系就如同管理员与羊，通过哈希值可以知道，孩子始终就一个，没有拷贝成功。
上面的错误是由于只拷贝了最外层对象的原因，我们称之为浅拷贝。为了解决这个问题，需要对内部的引用类型进行拷贝（Java中大部分引用类型实现了Cloneable接口，可以方便的拷贝），具体如下：
// 1.声明此类可以被clone
public class Sheep implements Cloneable {
// 前面省略
// 2.调用Object的clone方法
public Sheep startClone() {
Sheep sheep = null;
try {
sheep = (Sheep) super.clone();
// 3.调用Admin的clone方法
sheep.admin = this.admin.startClone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return sheep;
}
}
public class Admin implements Cloneable {
// 前面省略
public Admin startClone() {
Admin admin = null;
try {
admin = (Admin) super.clone();
admin.child = this.child.startClone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return admin;
}
}
public class Child implements Cloneable {
public Child startClone() {
Child child = null;
try {
child = (Child) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return child;
}
}
通过日志的打印，发现这种方式（深拷贝）起作用了。由1、2行可以知道，拷贝时引用类型已经重新创建了对象。由3、4行可以知道，修改其中一个对象不会再改变另一个了。
5.总结
原型模式通过Object的clone()方法实现，由于是内存操作，无视构造方法和访问权限，直接获取新的对象。但对于引用类型，需使用深拷贝，其它浅拷贝即可。
