设计模式(Design Patterns)-可复用面向对象软件的基础 05：原型模式(Prototype)和Java中的深、浅拷贝

原型模式(Prototype)

原型模式虽然是创建型的模式，但是与工厂模式没有关系，从名字即可看出，该模式的思想是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。本文将会通过对象的复制对原型模式进行讲解。

在Java中，复制对象是通过clone()实现的，先创建一个原型类：

package com.js.pattern5;/** * 原型模式 * 原型类 * @author Jiang * */public class Prototype implements Cloneable {public Object clone() throws CloneNotSupportedException{Prototype proto = (Prototype)super.clone();return proto;}}

很简单，一个原型类，只需要实现cloneable接口，重写clone()方法，此处clone()方法可以改成任意的名称，因为cloneable接口是个空接口：

/* * @(#)Cloneable.java1.17 05/11/17 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */package java.lang;/** * A class implements the <code>Cloneable</code> interface to  * indicate to the {@link java.lang.Object#clone()} method that it  * is legal for that method to make a  * field-for-field copy of instances of that class.  * <p> * Invoking Object's clone method on an instance that does not implement the  * <code>Cloneable</code> interface results in the exception  * <code>CloneNotSupportedException</code> being thrown. * <p> * By convention, classes that implement this interface should override  * <tt>Object.clone</tt> (which is protected) with a public method. * See {@link java.lang.Object#clone()} for details on overriding this * method. * <p> * Note that this interface does <i>not</i> contain the <tt>clone</tt> method. * Therefore, it is not possible to clone an object merely by virtue of the * fact that it implements this interface.  Even if the clone method is invoked * reflectively, there is no guarantee that it will succeed. * * @author  unascribed * @version 1.17, 11/17/05 * @see     java.lang.CloneNotSupportedException * @see     java.lang.Object#clone() * @since   JDK1.0 */public interface Cloneable { }

所以你可以任意定义实现类的方法名，如cloneA()或者cloneB()都可以，因为此处的重点是super.clone()这句话，super.clone()调用的是Object的clone()方法：

/**     * Creates and returns a copy of this object.  The precise meaning      * of "copy" may depend on the class of the object. The general      * intent is that, for any object <tt>x</tt>, the expression:     * <blockquote>     * <pre>     * x.clone() != x</pre></blockquote>     * will be true, and that the expression:     * <blockquote>     * <pre>     * x.clone().getClass() == x.getClass()</pre></blockquote>     * will be <tt>true</tt>, but these are not absolute requirements.      * While it is typically the case that:     * <blockquote>     * <pre>     * x.clone().equals(x)</pre></blockquote>     * will be <tt>true</tt>, this is not an absolute requirement.      * <p>     * By convention, the returned object should be obtained by calling     * <tt>super.clone</tt>.  If a class and all of its superclasses (except     * <tt>Object</tt>) obey this convention, it will be the case that     * <tt>x.clone().getClass() == x.getClass()</tt>.     * <p>     * By convention, the object returned by this method should be independent     * of this object (which is being cloned).  To achieve this independence,     * it may be necessary to modify one or more fields of the object returned     * by <tt>super.clone</tt> before returning it.  Typically, this means     * copying any mutable objects that comprise the internal "deep structure"     * of the object being cloned and replacing the references to these     * objects with references to the copies.  If a class contains only     * primitive fields or references to immutable objects, then it is usually     * the case that no fields in the object returned by <tt>super.clone</tt>     * need to be modified.     * <p>     * The method <tt>clone</tt> for class <tt>Object</tt> performs a      * specific cloning operation. First, if the class of this object does      * not implement the interface <tt>Cloneable</tt>, then a      * <tt>CloneNotSupportedException</tt> is thrown. Note that all arrays      * are considered to implement the interface <tt>Cloneable</tt>.      * Otherwise, this method creates a new instance of the class of this      * object and initializes all its fields with exactly the contents of      * the corresponding fields of this object, as if by assignment; the     * contents of the fields are not themselves cloned. Thus, this method      * performs a "shallow copy" of this object, not a "deep copy" operation.     * <p>     * The class <tt>Object</tt> does not itself implement the interface      * <tt>Cloneable</tt>, so calling the <tt>clone</tt> method on an object      * whose class is <tt>Object</tt> will result in throwing an     * exception at run time.     *     * @return     a clone of this instance.     * @exception  CloneNotSupportedException  if the object's class does not     *               support the <code>Cloneable</code> interface. Subclasses     *               that override the <code>clone</code> method can also     *               throw this exception to indicate that an instance cannot     *               be cloned.     * @see java.lang.Cloneable     */    protected native Object clone() throws CloneNotSupportedException;

而在Object类中，clone()是native的，具体怎么实现，涉及到Java本地方法的调用，此处暂不做深究。在此，我将结合对象的深复制和浅复制来说明原型模式，首先需要了解对象深、浅复制的概念：

浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。

深复制：将一个对象复制后，不论是基本数据类型还是引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制(不涉及数据共享，是完完全全的两份)，而浅复制不彻底。

此处，写一个深浅复制的例子：

package com.js.pattern5;import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.Serializable;/** * 原型模式 * 原型类 * 深复制、浅复制 * @author Jiang * */public class Prototype implements Cloneable {private static final long serialVersionUID = 1L;private  String string;private SerializableObject obj;/*浅复制*/public Object clone() throws CloneNotSupportedException{Prototype proto = (Prototype)super.clone();return proto;}/*深复制*/public Object deepClone() throws IOException, ClassNotFoundException{/*写入当前对象的二进制流*/ByteArrayOutputStream bos = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(bos);oos.writeObject(this);/*读出二进制流产生的新对象*/ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());ObjectInputStream ois = new ObjectInputStream(bis);return ois.readObject();}public String getString() {return string;}public void setString(String string) {this.string = string;}public SerializableObject getObj() {return obj;}public void setObj(SerializableObject obj) {this.obj = obj;}}class SerializableObject implements Serializable{private static final long serialVersionUID = 1L;}

要实现深复制，一般情况下我们采用流的形式读入当前对象的二进制输入，这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象或属性可否设成transient，从而将之排除在复制过程之外。再写出二进制数据对应的对象。

当然，重写clone()的方式也可以实现深拷贝，我这里也简单的举个例子：

首先，先看浅拷贝：

class Professor {   String name;   int age;   Professor(String name,int age)   {   this.name=name;   this.age=age;   } } public class Student implements Cloneable {   String name;// 常量对象。   int age;   Professor p;// 学生1和学生2的引用值都是一样的。   Student(String name,int age,Professor p)   {   this.name=name;   this.age=age;   this.p=p;   }  public Object clone()   {    Student o=null;   try   {     o=(Student)super.clone();    }   catch(CloneNotSupportedException e)    {     System.out.println(e.toString());    }    o.p=(Professor)p.clone();   return o;   }   public static void main(String[] args)  {   Professor p=new Professor("wangwu",50);   Student s1=new Student("zhangsan",18,p);   Student s2=(Student)s1.clone();   s2.p.name="lisi";   s2.p.age=30;    System.out.println("name="+s1.p.name+","+"age="+s1.p.age);  System.out.println("name="+s2.p.name+","+"age="+s2.p.age);  //输出结果学生1和2的教授成为lisi,age为30。  } }

先用二进制方式来实现其深拷贝：

public Object deepClone() {  //将对象写到流里  ByteArrayOutoutStream 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()); }

采用二进制方式实现深拷贝的改进代码：

class Teacher implements Serializable{  String name;  int age;  public void Teacher(String name,int age){  this.name=name;  this.age=age;  }}public class Student implements Serializable{ String name;//常量对象 int age; Teacher t;//学生1和学生2的引用值都是一样的。 public void Student(String name,int age,Teacher t){  this.name=name;  this.age=age;  this.p=p; } public Object deepClone() throws IOException,    OptionalDataException,ClassNotFoundException{//将对象写到流里  ByteArrayOutoutStream 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()); } public static void main(String[] args){   Teacher t=new Teacher("tangliang",30);  Student s1=new Student("zhangsan",18,t);  Student s2=(Student)s1.deepClone();  s2.t.name="tony";  s2.t.age=40;  //学生1的老师不改变  System.out.println("name="+s1.t.name+","+"age="+s1.t.age); }}

那应该如何使用clone()方法实现深层次的克隆，即修改s2的教授不会影响s1的教授？代码改进如下。 
改进使学生1的Professor不改变（深层次的克隆） 

class Professor implements Cloneable {   String name;   int age;   Professor(String name,int age)   {   this.name=name;   this.age=age;   }  public Object clone()   {    Object o=null;   try   {     o=super.clone();    }   catch(CloneNotSupportedException e)    {     System.out.println(e.toString());    }   return o;   } } public class Student implements Cloneable {   String name;   int age;   Professor p;   Student(String name,int age,Professor p)   {   this.name=name;   this.age=age;   this.p=p;   }  public Object clone()   {    Student o=null;   try   {     o=(Student)super.clone();    }   catch(CloneNotSupportedException e)    {     System.out.println(e.toString());    }    //对引用的对象也进行复制   o.p=(Professor)p.clone();   return o;   }   public static void main(String[] args)   {   Professor p=new Professor("wangwu",50);   Student s1=new Student("zhangsan",18,p);   Student s2=(Student)s1.clone();   s2.p.name="lisi";   s2.p.age=30;   //学生1的教授不 改变。  System.out.println("name="+s1.p.name+","+"age="+s1.p.age);   System.out.println("name="+s2.p.name+","+"age="+s2.p.age);  } }