原型模式——浅复制与深复制
原型模式涉及一个浅复制和深复制的概念。原型模式可以简单理解为“复制”,但这个复制不是代码的复制。对同一个类,我们可以实例化new三次来“复制”,但如果在初始化的时候构造函数的执行很长,多次实例化就显得效率很低效了。那我们能否只实例化一次,然后“复制”呢?
Test test1 = new Test(); Test test2 = test1; Test test3 = test1;
这样写吗?注意这是引用的复制,这实际上还是只有test1一个实例,test2、test3只是复制了其引用而已,如果修改了一个对象则会影响到其他的对象。这样是不符合我们要求的。这就会引出我们Java的clone方法浅复制和深复制了。
我们先来看浅复制是什么。对于要实现克隆(我们后面将浅复制和深复制统称为克隆),必须实现Cloneable接口,尽管clone方法在Object类里,但我们还是得实现Cloneable接口不然会抛出CloneNotSupportedException错误。
定义一个Resume类实现Cloneable接口,并实现Object类中的clone方法。
1 package day_12_prototype; 2 3 /** 4 * @author turbo 5 * 6 * 2016年9月17日 7 */ 8 public class Resume implements Cloneable { 9 private String name; 10 private String sex; 11 12 public String getName() { 13 return name; 14 } 15 16 public void setName(String name) { 17 this.name = name; 18 } 19 20 public String getSex() { 21 return sex; 22 } 23 24 public void setSex(String sex) { 25 this.sex = sex; 26 } 27 28 @Override 29 protected Object clone() throws CloneNotSupportedException { 30 Resume resume = (Resume)super.clone(); 31 return resume; 32 } 33 34 }
客户端测试代码:
1 package day_12_prototype; 2 3 /** 4 * @author turbo 5 * 6 * 2016年9月17日 7 */ 8 public class Main { 9 10 /** 11 * @param args 12 * @throws CloneNotSupportedException 13 */ 14 public static void main(String[] args) throws CloneNotSupportedException { 15 Resume resume1 = new Resume(); 16 Resume resume2 = (Resume)resume1.clone(); 17 System.out.println(resume1.hashCode() + " " + resume2.hashCode()); 18 } 19 20 }
我们可以看看输出结果,resume2是否只是复制了resume1的引用。
看来并不是。并且我们也成功地克隆了一个对象,并不是简单地复制了引用。我们的Resume类里只有两个String基本类型,我们来看看如果有其他引用会是什么样子的。
1 package day_12_prototype; 2 3 /** 4 * @author turbo 5 * 6 * 2016年9月17日 7 */ 8 public class Resume implements Cloneable { 9 private String name; 10 private String sex; 11 private Test test = new Test(); 12 13 public String getName() { 14 return name; 15 } 16 17 public void setName(String name) { 18 this.name = name; 19 } 20 21 public String getSex() { 22 return sex; 23 } 24 25 public void setSex(String sex) { 26 this.sex = sex; 27 } 28 29 public Test getTest() { 30 return test; 31 } 32 33 public void setTest(Test test) { 34 this.test = test; 35 } 36 37 @Override 38 protected Object clone() throws CloneNotSupportedException { 39 Resume resume = (Resume)super.clone(); 40 return resume; 41 } 42 43 }
此时我们增加了一个Test类的引用,其他代码不变,Test类里什么都没有。看看客户端代码:
1 package day_12_prototype; 2 3 /** 4 * @author turbo 5 * 6 * 2016年9月17日 7 */ 8 public class Main { 9 10 /** 11 * @param args 12 * @throws CloneNotSupportedException 13 */ 14 public static void main(String[] args) throws CloneNotSupportedException { 15 Resume resume1 = new Resume(); 16 Resume resume2 = (Resume)resume1.clone(); 17 System.out.println(resume1.hashCode() + " " + resume2.hashCode()); 18 System.out.println(resume1.getTest().hashCode() + " " + resume2.getTest().hashCode()); 19 } 20 21 }
这个时候对第18行的输出结果会是什么样的呢?
我们看到虽然我们对resume1进行了克隆,resume2确实也是新的引用,但由于Resume类中有了对另外一个类的引用,所以resume1和resume2对Test对象的引用还是同一个,这就是浅复制。那么如何做到连同Test对象一起克隆,而不是只复制一个引用呢?这就是深复制的概念。
我们首先对在Resume中被引用的类Test做一点改变,让它实现Cloneable接口,实现clone方法:
1 package day_12_prototype; 2 3 /** 4 * @author turbo 5 * 6 * 2016年9月17日 7 */ 8 public class Test implements Cloneable{ 9 private String test; 10 11 public String getTest() { 12 return test; 13 } 14 15 public void setTest(String test) { 16 this.test = test; 17 } 18 19 @Override 20 protected Object clone() throws CloneNotSupportedException { 21 return super.clone(); 22 } 23 24 }
同样在Resume类中做一点微小的改变:
1 package day_12_prototype; 2 3 /** 4 * @author turbo 5 * 6 * 2016年9月17日 7 */ 8 public class Resume implements Cloneable { 9 private String name; 10 private String sex; 11 private Test test = new Test(); 12 13 public String getName() { 14 return name; 15 } 16 17 public void setName(String name) { 18 this.name = name; 19 } 20 21 public String getSex() { 22 return sex; 23 } 24 25 public void setSex(String sex) { 26 this.sex = sex; 27 } 28 29 public Test getTest() { 30 return test; 31 } 32 33 public void setTest(Test test) { 34 this.test = test; 35 } 36 37 @Override 38 protected Object clone() throws CloneNotSupportedException { 39 Resume resume = (Resume)super.clone(); 40 resume.test = (Test)test.clone(); 41 return resume; 42 } 43 44 }
客户端测试代码不变:
1 package day_12_prototype; 2 3 /** 4 * @author turbo 5 * 6 * 2016年9月17日 7 */ 8 public class Main { 9 10 /** 11 * @param args 12 * @throws CloneNotSupportedException 13 */ 14 public static void main(String[] args) throws CloneNotSupportedException { 15 Resume resume1 = new Resume(); 16 Resume resume2 = (Resume)resume1.clone(); 17 System.out.println(resume1.hashCode() + " " + resume2.hashCode()); 18 System.out.println(resume1.getTest().hashCode() + " " + resume2.getTest().hashCode()); 19 } 20 21 }
输出结果:
这样我们就实现了对象的深复制。
说完浅复制与深复制,其实我们也就讲完了原型模式:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。为什么要通过克隆的方式来创建新的对象,也即是我们在上面提到的,每new一次都需要执行一次构造函数,如果构造函数的执行时间很长,那么多次执行这个初始化操作就实在是太低效了。