Java 设计模式-原型模式(克隆)
一、什么是原型模式
原型模式(Prototype)，用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。简单说，就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建细节。
二、原型的引入克隆
现在我们有一个需求，要求有一个简历类，必须要有姓名，可以设置性别和年龄，可以设置工作经历。最终我们需要写三份简历。
通常，在不用原型模式的情况下，是这样实现的。方式一：
简历类
class Resume
{
private String name;
private String gender;
private String age;
private String timeArea;
private String company;
public Resume(String name){
this.name = name;
}
public void setPersonInfo(String gender,String age){
this.gender = gender;
this.age = age;
}
public void setWorkExperience(String timeArea, String company){
this.timeArea = timeArea;
this.company = company;
}
public void display(){
System.out.print(name +" "+ gender +" "+age);
System.out.print("工作经历 "+ timeArea +" "+company);
}
}
客户端调用代码
static void main(String[] args){//此处也可为for循环创建
Resume a = new Resume("张三");
a.setPersonInfo("男" , "30");
a.setWorkExperience("2010-2018" , "xx公司");
Resume b = new Resume("张三");
b.setPersonInfo("男" , "30");
b.setWorkExperience("2010-2018" , "xx公司");
Resume c = new Resume("张三");
c.setPersonInfo("男" , "30");
c.setWorkExperience("2010-2018" , "xx公司");
a.display();
b.display();
c.display();
}
结果显示
张三 男 30
工作经历 2010-2018 xx公司
张三 男 30
工作经历 2010-2018 xx公司
张三 男 30
工作经历 2010-2018 xx公司
这里我们看到3份简历需要三次实例化，这样是不是有点麻烦，如果需要100份，那我们就要实例化100次。一旦写错了一个字，都要改100次。
当然我们想偷懒一下，可以这样写。
Resume a = new Resume("张三");
a.setPersonInfo("男" , "30");
a.setWorkExperience("2010-2018" , "xx公司");
Resume b = a;//传引用而不传值
Resume c = a;
a.display();
b.display();
c.display();
以上创建对象是通过new方式创建的，但是在我们熟知的概念中，还有一种创建对象的方式是克隆方法。顾名思义，是通过已有的对象复制一个新的对象一模一样的。即我们上面原型模式的定义，所以clone方法是一种原型模式设计模式。下面我们来看一下，克隆方法的使用示例。
//注意此种方式，叫引用复制，得到的对象与原来对象一样，而非创建一个新对象
Resume r = new Resume("张三");
Resume b = r ;
方式二：让被复制的对象类继承接口Cloneable（System已经提供了），并重写clone()方法。
public class Resume implements Cloneable {
private String name;
private String gender;
private String age;
private String timeArea;
private String company;
public Resume(String name) {
this.name = name;
}
public void setPersonInfo(String gender, String age) {
this.gender = gender;
this.age = age;
}
public void setWorkExperience(String timeArea, String company) {
this.timeArea = timeArea;
this.company = company;
}
public void display() {
System.out.print(name +" "+ gender +" "+age);
System.out.print("工作经历 "+ timeArea +" "+company);
}
//只需要调用此方法就可以实现新简历(对象)的生成，且可以再次改新简历的细节
@Override
protected Object clone() throws CloneNotSupportedException {
return (Resume) super.clone();
}
}
调用代码
Resume resume = Resume("张三丰");
resume.setPersonInfo("男", "30");
resume.setWorkExperience("2010-1018", "xx公司");
Resume cloneResume = (Resume) resume.clone() ;
cloneResume.setPersonInfo("女", "21");
Resume cloneResume2 = (Resume) resume.clone() ;
cloneResume2.setWorkExperience("2015-2018", "xx公司");
结果为:
张三丰 男 30
工作经历 2010-1018 xx公司
张三丰 女 21
工作经历 2010-1018 xx公司
张三丰 男 30
工作经历 2015-2018 xx公司
两种方法都可以实现。但是方式一每new一次，就需要执行一次构造函数，如果构造行数的执行时间很长，那么多次的执行初始化操作就太低效率了。一般在初始化的信息不发生变化的情况下，方式二克隆是最好的办法。这既隐藏了对象的创建细节，又对性能是大大的提高。不用重新初始化对象，动态获得对象运行时的状态。
三、浅复制与深复制
上面的例子，对象的属性都是String类型，而String类型是一种拥有值类型特点的特殊引用类型。clone()方法是这样的，如果字段是值类型的，则对该字段执行逐位复制，如果字段是引用类型，则复制引用但不复制引用的对象，因此，原始对象及其复本引用同一对象。以简历的例子讲，假设WorkExperience作为简历类的属性，那么在克隆后，会把引用对象中的数据克隆过来吗？
public class Resume implements Cloneable {
private String name;
private String gender;
private String age;
private WorkExperience experience;
public Resume(String name) {
this.name = name;
experience = new WorkExperience();
}
public void setPersonInfo(String gender, String age) {
this.gender = gender;
this.age = age;
}
public void setWorkExperience(String timeArea, String company) {
experience.setWorkDate(timeArea);
experience.setCompany(company);
}
public void display() {
System.out.print(name +" "+ gender +" "+age);
System.out.print("工作经历 " + experience.getWorkDate() + " " +experience.getCompany());
}
@Override
protected Object clone() throws CloneNotSupportedException {
return (Resume) super.clone();
}
}
工作经验类
public class WorkExperience {
private String workDate;
private String company;
public String getWorkDate() {
return workDate;
}
public void setWorkDate(String workDate) {
this.workDate = workDate;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
}
调用代码
Resume resume = Resume("张三丰");
resume.setPersonInfo("男", "30");
resume.setWorkExperience("2010-1018", "麦当劳公司");
Resume cloneResume = resume.clone() ;
cloneResume.setPersonInfo("男", "22");
cloneResume.setWorkExperience("2017-1018", "肯德基公司");
Resume cloneResume2 = (Resume)resume.clone();
cloneResume2.setPersonInfo("女", "24");
cloneResume2.setWorkExperience("2015-2018", "德克士公司");
resume.display();
cloneResume.display();
cloneResume2.display();
结果显示：
张三丰 男 30
工作经历 2015-2018 德克士公司
张三丰 男 22
工作经历 2015-2018 德克士公司
张三丰 女 24
工作经历 2015-2018 德克士公司
并没有我们想要的结果，三次显示都是最后一次设置的值。通过查帮助文档，我们知道clone()方法是浅表复制，对于值类型，没有什么问题，但对于引用类型，就只是复制了引用，还是指向了原来的对象，所以就会出现上面的结果，三次结果相同。
浅复制，被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。但我们可能更需要这样的一种需求，把要复制的对象所引用的对象都复制一遍。比如刚才的例子，我们希望是a,b,c三个引用的对象都是不同的，复制时就一变二，二变三，此时，我们就叫这种方式为‘深复制’，深复制把引用对象的变量指向复制过的新对象，而不是原有的被引用的对象。
继续改造上面浅复制为深复制
public class Resume implements Cloneable {
private String name;
private String gender;
private String age;
private WorkExperience experience;
public Resume(String name) {
this.name = name;
experience = new WorkExperience();
}
private Resume(WorkExperience experience) {
this.experience = (WorkExperience) experience.clone();
}
public void setPersonInfo(String gender, String age) {
this.gender = gender;
this.age = age;
}
public void setWorkExperience(String timeArea, String company) {
experience.setWorkDate(timeArea);
experience.setCompany(company);
}
public void display() {
System.out.print(name +" "+ gender +" "+age);
System.out.print("工作经历 " + experience.getWorkDate() + " " +experience.getCompany());
}
@Override
protected Object clone(){
Resume r = new Resume(this.experience);
r.name = this.name;
r.gender = this.gender;
r.age = this.age;
return r;
}
}
工作经验类改造，继承克隆接口，重写clone方法
public class WorkExperience implements Cloneable {
private String workDate;
private String company;
public String getWorkDate() {
return workDate;
}
public void setWorkDate(String workDate) {
this.workDate = workDate;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return (WorkExperience) super.clone();
}
}
调用代码
Resume resume = Resume("张三丰");
resume.setPersonInfo("男", "30");
resume.setWorkExperience("2010-1018", "麦当劳公司");
Resume cloneResume = resume.clone() ;
cloneResume.setPersonInfo("男", "22");
cloneResume.setWorkExperience("2017-1018", "肯德基公司");
Resume cloneResume2 = (Resume)resume.clone();
cloneResume2.setPersonInfo("女", "24");
cloneResume2.setWorkExperience("2015-2018", "德克士公司");
resume.display();
cloneResume.display();
cloneResume2.display();
结果显示：
张三丰 男 30
工作经历 2010-1018 麦当劳公司
张三丰 男 22
工作经历 2017-1018 肯德基公司
张三丰 女 24
工作经历 2015-2018 德克士公司
这就达到了我们想要的结果，三份不同的简历。由于在一些特定场合，会经常涉及深复制或浅复制，比如说数据集对象DataSet，它就有clone()方法和copy()方法，clone方法用来复制DataSet的结构，但不复制DataSet的数据，实现了原型模式的浅复制。copy方法不但复制结构，也复制数据，其实就是实现了原型模式的深复制。
四、使用场景：
1、资源优化场景。
2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。
4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
五、注意事项：
与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写clone方法。深复制是，采用对象的序列化Serializable技术进行clone,对象的序列化会将对象以及对象的句柄的内容都序列化，然后输出到对象的流中，可以将流直接保存到内存二级制流中，然后再用对象输入流从内存二进制中读取该流，再转换成相应的对象，这样就完成了非常复杂而且是深层次的复制。
