设计模式之原型模式介绍-深拷贝

一个引用对象一般来说由两个部分组成：一个具名的Handle，也就是我们所说的声明（如变量）和一个内部（不具名）的对象，也就是具名Handle的内部对象。它在Manged Heap（托管堆）中分配，一般由新增引用对象的New方法是进行创建。深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。比较典型的就是Value（值）对象，如预定义类型Int32，Double，以及结构（struct），枚举（Enum）等。

如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，浅拷贝会带来数据安全方面的隐患。在进行赋值之前，为指针类型的数据成员另辟了一个独立的内存空间，实现真正内容上的拷贝 。这种拷贝称为深拷贝。深拷贝有两种方式实现：层层clone的方法和利用串行化来做深拷贝。层层clone的方法：在浅拷贝的基础上实现，给引用类型的属性添加克隆方法，并且在拷贝的时候也实现引用类型的拷贝。此种方法由于要在多个地方实现拷贝方法，可能会造成混论。利用串行化来做深拷贝：为避免复杂对象中使用clone方法可能带来的换乱，可以使用串化来实现深拷贝。先将对象写到流里，然后再从流里读出来。

深拷贝会拷贝所有的属性，并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

构造函数

在C+ +面向对象程序设计中，通过构造函数对对象进行初始化，它可以为对象在计算机内存中开辟内存空间，也可以为对象的数据成员提供初始值。构造函数是一个与类同名，没有返回值的特殊成员函数，每当创建一个对象时(包括使用new动态创建对象)，编译系统就会自动调用构造函数。构造函数象类以外的一般函数和类成员函数一样可以重载和带缺省参数，构造函数的重载为对象的生成提供了各种灵活的手段。构造函数分为缺省构造函数(默认构造函数)和用户自定义构造函数。当程序员没有定义构造函数时，系统会提供一个无参的缺省构造函数。如果用户自定义了一个构造函数，编译器提供的缺省构造函数就自动消失了。

拷贝构造函数

拷贝构造函数的功能是用一个已有的对象来初始化一个被创建的同类的对象，是一种特殊的构造函数，具有一般构造函数的所有特性，其形参是本类对象的引用。用户可以根据自己实际问题的需要定义特定的拷贝构造函数，以实现同类对象之间数据成员的传递。如果用户没有声明类的拷贝构造函数，系统就会自动生成一个缺省拷贝构造函数，这个缺省拷贝构造函数的功能是把初始对象的每个数据成员的值都复制到新建立的对象中。

1.复制对象的所有基本数据类型的成员变量值

2 . 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象，也就是说，对象进行深拷贝要对整个对象（包括对象的引用类型）进行拷贝

3 . 实现方式

• 重写clone方法实现

• 通过对象序列化实现

4 . 代码实现

//定义一个类，下面的测试中引用此类
public class DeepCloneableTarget implements Serializable, Cloneable {
   /**
   *
   */
   private static final long serialVersionUID = 1L;
   private String cloneName;
   private String cloneClass;

   //构造器
   public DeepCloneableTarget(String cloneName, String cloneClass) { this.cloneName = cloneName;
      this.cloneClass = cloneClass;
   }

   //因为该类的属性，都是 String , 因此我们这里使用默认的 clone 完成即可
   @Override
   protected Object clone() throws CloneNotSupportedException {
      return super.clone();
   }
}


//第二个类，用于引用上面的类
public class DeepProtoType implements Serializable, Cloneable {
   public String name; //String 属 性
   public DeepCloneableTarget deepCloneableTarget;// 引用类型

   public DeepProtoType() {
      super();
   }


   //深拷贝 - 方式 1 使用 clone 方法
   @Override
   protected Object clone() throws CloneNotSupportedException {
      Object deep = null;
      //这里完成对基本数据类型(属性)和 String 的克隆
      deep = super.clone();
      //对引用类型的属性，进行单独处理
      DeepProtoType deepProtoType = (DeepProtoType) deep;
      deepProtoType.deepCloneableTarget = (DeepCloneableTarget) deepCloneableTarget.clone();
      return deepProtoType;
   }

    //深拷贝 - 方式 2 通过对象的序列化实现 (推荐)
    public Object deepClone() {
       //创建流对象
       ByteArrayOutputStream bos = null;
       ObjectOutputStream oos = null;
       ByteArrayInputStream bis = null;
       ObjectInputStream ois = null;
       try {
           //序列化
           bos = new ByteArrayOutputStream();
           oos = new ObjectOutputStream(bos);
           oos.writeObject(this); //当前这个对象以对象流的方式输出


    //反序列化
    bis = new ByteArrayInputStream(bos.toByteArray());
    ois = new ObjectInputStream(bis);
    DeepProtoType copyObj = (DeepProtoType) ois.readObject();
    return copyObj;
   } catch (Exception e) {
    e.printStackTrace();
    return null;
   } finally {
    //关闭流
    try {
         bos.close();
         oos.close();
         bis.close();
         ois.close();
    } catch (Exception e2) {
         // TODO: handle exception
         System.out.println(e2.getMessage());
     }
   }
 }
}

测试类

//测试类
public class Client {
     public static void main(String[] args) throws Exception {
     DeepProtoType p = new DeepProtoType();
     p.name = "宋江";
     p.deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛");
   //方式 1 完成深拷贝
   // DeepProtoType p2 = (DeepProtoType) p.clone();
   //
   // System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
   // System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
   // 方式 2 完成深拷贝
   DeepProtoType p2 = (DeepProtoType) p.deepClone();
   System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
   System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
   }
}