设计模式——原型模式

原型模式

　　原型模式，用原型示例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 　　简单原型模式的结构： 　　 其中： 　　prototype:原型类，声明一个克隆自身的接口 　　client:让一个原型克隆自身从而创建一个新的对象 　　concretePrototype：具体的原型类，实现一个克隆自身的操作。

　　原型模式起始就是从一个对象再创建另一个可定制的对象，而且不需要知道任何创建的细节。它等于是不用重复初始化对象，而是动态地获取对象运行时的状态。

具体实现代码如下： 接口类

public interface Property { public Property cloneResume(); }

具体实现类

public class Resume implements Property , Cloneable { private String name; private int age; private String sex; private String timeArea; private String company; public Resume(String name) { this.name = name; } public void setPersonalInfo( int age , String sex ) { this.age = age; this.sex = sex; } public void setWorkExperience( String timeArea , String company ) { this.timeArea = timeArea; this.company = company; } public void display() { System.out.println(name + "," + sex + "," + age); System.out.println("工作经历 :" + timeArea + "," + company); } public Property cloneResume() { try { return (Property)this.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); return null; } } }

其中实现类额外实现Cloneable 接口 ，这样就可以调用object的clone方法，创建一个自身对象的副本。

测试类：

public class Test { public static void main(String[] args) { Resume a = new Resume("小菜"); a.setPersonalInfo(24, "男"); a.setWorkExperience("2016-2017", "上海"); Resume b = (Resume)a.cloneResume(); b.setPersonalInfo(25, "大菜"); a.display(); b.display(); System.out.println("a == b ? :" + (a == b)); } }

输出结果：

Java中的克隆方法 　　Java的所有类都是从java.lang.Object类继承而来的，而Object类提供protected Object clone()方法对对象进行复制，子类当然也可以把这个方法置换掉，提供满足自己需要的复制方法。对象的复制有一个基本问题，就是对象通常都有对其他的对象的引用。当使用Object类的clone()方法来复制一个对象时，此对象对其他对象的引用也同时会被复制一份

　　Java语言提供的Cloneable接口只起一个作用，就是在运行时期通知Java虚拟机可以安全地在这个类上使用clone()方法。通过调用这个clone()方法可以得到一个对象的复制。由于Object类本身并不实现Cloneable接口，因此如果所考虑的类没有实现Cloneable接口时，调用clone()方法会抛出CloneNotSupportedException异常。

克隆满足的条件 　　clone()方法将对象复制了一份并返还给调用者。所谓“复制”的含义与clone()方法是怎么实现的。一般而言，clone()方法满足以下的描述：

　　（1）对任何的对象x，都有：x.clone()!=x。换言之，克隆对象与原对象不是同一个对象。

　　（2）对任何的对象x，都有：x.clone().getClass() == x.getClass()，换言之，克隆对象与原对象的类型一样。

　　（3）如果对象x的equals()方法定义其恰当的话，那么x.clone().equals(x)应当成立的。

　　在JAVA语言的API中，凡是提供了clone()方法的类，都满足上面的这些条件。JAVA语言的设计师在设计自己的clone()方法时，也应当遵守着三个条件。一般来说，上面的三个条件中的前两个是必需的，而第三个是可选的。

浅克隆和深克隆 　　无论你是自己实现克隆方法，还是采用Java提供的克隆方法，都存在一个浅度克隆和深度克隆的问题。

　　浅度克隆 　　只负责克隆按值传递的数据（比如基本数据类型、String类型），而不复制它所引用的对象，换言之，所有的对其他对象的引用都仍然指向原来的对象。

　　深度克隆 　　除了浅度克隆要克隆的值外，还负责克隆引用类型的数据。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深度克隆把要复制的对象所引用的对象都复制了一遍，而这种对被引用到的对象的复制叫做间接复制。

　　深度克隆要深入到多少层，是一个不易确定的问题。在决定以深度克隆的方式复制一个对象的时候，必须决定对间接复制的对象时采取浅度克隆还是继续采用深度克隆。因此，在采取深度克隆时，需要决定多深才算深。此外，在深度克隆的过程中，很可能会出现循环引用的问题，必须小心处理。

利用序列化实现深度克隆 　　把对象写到流里的过程是序列化(Serialization)过程；而把对象从流中读出来的过程则叫反序列化(Deserialization)过程。应当指出的是，写到流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。

　　在Java语言里深度克隆一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的拷贝）写到一个流里（序列化），再从流里读回来（反序列化），便可以重建对象。

　　这里我们将工作经历抽取成一个对象，来验证一下java的clone方法是浅层克隆

工作经历对象：

public class WorkExperience implements Serializable { /** * */ private static final long serialVersionUID = -6649732674110676004L; private String timeArea; private String company; public String getTimeArea() { return timeArea; } public void setTimeArea(String timeArea) { this.timeArea = timeArea; } public String getCompany() { return company; } public void setCompany(String company) { this.company = company; } }

改造后的简历对象：

public class Resume implements Property , Cloneable , Serializable { /** * */ private static final long serialVersionUID = 2132098259937492143L; private String name; private int age; private String sex; private WorkExperience work; public Resume(String name) { this.name = name; } public void setPersonalInfo( int age , String sex ) { this.age = age; this.sex = sex; } public void setWorkExperience( WorkExperience work ) { this.work = work; } public void display() { System.out.println(name + "," + sex + "," + age); System.out.println("工作经历 :" + work.getTimeArea() + "," + work.getCompany()); } public Property cloneResume() { try { return (Property)this.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); return null; } } public WorkExperience getWork() { return work; } public void setWork(WorkExperience work) { this.work = work; } }

测试类：

public class Test { public static void main(String[] args) { Resume a = new Resume("小菜"); a.setPersonalInfo(24, "男"); WorkExperience work = new WorkExperience(); work.setTimeArea("2016-2017"); work.setCompany("上海"); a.setWorkExperience(work); Resume b = (Resume)a.cloneResume(); b.setPersonalInfo(25, "大菜"); a.display(); b.display(); System.out.println("a.work == b.work ? :" + (a.getWork() == b.getWork())); } }

输出结果： 这里可以看到java的clone是浅层克隆

如果要实现深度克隆 就要利用流 具体代码如下

public Property cloneResume() throws Exception { //将对象写到流里 ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(this); //从流里读回来 ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bis); return (Property)ois.readObject(); }

结果：

原型模式的优点 　　原型模式允许在运行时动态改变具体的实现类型。原型模式可以在运行期间，由客户来注册符合原型接口的实现类型，也可以动态地改变具体的实现类型，看起来接口没有任何变化，但其实运行的已经是另外一个类实例了。因为克隆一个原型就类似于实例化一个类。

原型模式的缺点 　　原型模式最主要的缺点是每一个类都必须配备一个克隆方法。配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类来说不是很难，而对于已经有的类不一定很容易，特别是当一个类引用不支持序列化的间接对象，或者引用含有循环结构的时候。