JavaSE 深复制与浅复制(原型模式实现方式)-原创手记-慕课网

Java 深克隆(DeepClone)与浅克隆(ShallowClone)是原型设计模式的灵魂。
记录结构：
--什么是浅克隆？
--实现浅克隆
--什么是深克隆？
--实现深克隆

需求

Sunny 软件公司 OA 系统支持工作周报的快速克隆，极大提高了工作周报的编写效率，受到员工的一致好评。但有员工又发现一个问题，有些工作周报带有附件，例如经理助理“小龙女”的周报通常附有本周项目进展报告汇总表、本周客户反馈信息汇总表等，如果使用上述原型模式来复制周报，周报虽然可以复制，但是周报的附件并不能复制，这是由于什么原因导致的呢？如何才能实现周报和附件的同时复制呢？
在解决问题之前了解一下浅克隆与深克隆。

浅克隆

浅克隆
在浅克隆中,如果原型对象的成员变量是值类型,将复制一份给克隆对象;如果原型对象的成员变量是引用类型,则将引用对象的地址复制一份给克隆对象,也就是说原型对象和克隆对象的成员变量指向相同的内存地址。简单来说,在浅克隆中,当对象被复制时只复制它本身和其中包含的值类型的成员变量,而引用类型的成员对象并没有复制,如图所示:
浅复制示意图.gif

实现浅克隆

在 Java 语言中，通过覆盖 Object 类的 clone() 方法可以实现浅克隆。为了让大家更好地理解浅克隆和深克隆的区别，我们首先使用浅克隆来实现工作周报和附件类的复制，其结构如图所示：

浅复制实现周报clone.gif

代码如下所示：
Attachement.java(附件实体类)

public class Attachement {   
   private  String name; //附件名称   
   public String getName() {  
        return name;  
   }   
   public void setName(String name) {
        this.name = name;    
   }   
   public void downLoad() {        
        System.out.println(name+"被下载");    
   }
}

WeeklyLog.java(周报类)聚合了Attachement对象

/** * Created by mark on 16/10/19. 
    * @usage 实现浅复制 
    * 浅复制 实现的是对对象中值类型(基本数据类型)引用类型的复制 
    * 基本数据类型 全复制 
    * 引用数据类型 对引用类型对象的地址的复制 
    * 这样两个对象之间会有关联，没有实现完全的分离，一旦当中的某个引用类型对象发生变化， 
    * 那么这两个对象都会发生变化 
    */
public class WeeklyLog implements Cloneable {    
       private Attachement attachment;    
       private String date;    
       private String content;    
       public Attachement getAttachment() {        
              return attachment;   
       }   
       public void setAttachment(Attachement attachment) {
             this.attachment = attachment;                           
       }    
       public String getDate() {        
             return date;   
       }    
       public void setDate(String date) {        
             this.date = date;    
       }    
       public String getContent() {        
             return content;    
       }    
       public void setContent(String content) {        
             this.content = content;    
       }    
       public WeeklyLog clone() {        
            Object object = null;       
            try {           
                   object = super.clone();//调用Object clone方法            
                   return (WeeklyLog)object;        
            }catch (CloneNotSupportedException e) { 
                   e.printStackTrace();                                 
                   return null;        
           }   
      }
}

客户端代码如下所示：

class Client {
       public  static void main(String args[]) {
              WeeklyLog  log_previous, log_new;
              log_previous  = new WeeklyLog(); //创建原型对象
              Attachment  attachment = new Attachment(); //创建附件对象
              log_previous.setAttachment(attachment);  //将附件添加到周报中
              log_new  = log_previous.clone(); //调用克隆方法创建克隆对象
              //比较周报
              System.out.println("周报是否相同？ " + (log_previous ==  log_new));
              //比较附件
              System.out.println("附件是否相同？ " +  (log_previous.getAttachment() == log_new.getAttachment()));
       }
}

编译并运行程序，输出结果如下：

周报是否相同？  false
附件是否相同？  true

由于使用的是浅克隆技术，因此工作周报对象复制成功，通过“==”比较原型对象和克隆对象的内存地址时输出 false；但是比较附件对象的内存地址时输出 true，说明它们在内存中是同一个对象。

什么是深克隆？

在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对象。简单来说，在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量也将复制，如图所示：

深克隆示意图jpg.gif

在 Java 语言中，如果需要实现深克隆，可以通过序列化（Serialization）等方式来实现。序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个拷贝，而原对象仍然存在于内存中。通过序列化实现的拷贝不仅可以复制对象本身，而且可以复制其引用的成员对象，因此通过序列化将对象写到一个流中，再从流里将其读出来，可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现 Serializable 接口，否则无法实现序列化操作。下面我们使用深克隆技术来实现工作周报和附件对象的复制，由于要将附件对象和工作周报对象都写入流中，因此两个类均需要实现 Serializable 接口，其结构如图所示：

深克隆实现周报中附件复制.gif

修改后的附件类 Attachment 代码如下：

import  java.io.*;
//附件类
class  Attachment implements Serializable {
       private  String name; //附件名
       public  void setName(String name) {
              this.name  = name;
       }
       public  String getName() {
              return  this.name;
       }
       public void download() {
            System.out.println("下载附件，文件名为" + name);
       }
}

工作周报类 WeeklyLog 不再使用 Java 自带的克隆机制，而是通过序列化来从头实现对象的深克隆，我们需要重新编写 clone() 方法，修改后的代码如下：

import  java.io.*;
//工作周报类
class  WeeklyLog implements Serializable {
       private  Attachment attachment;
       private  String name;
       private  String date;
       private  String content;
       public  void setAttachment(Attachment attachment) {
              this.attachment  = attachment;
       }
       public  void setName(String name) {
              this.name  = name;
       }
       public  void setDate(String date) {
              this.date  = date;
       }
       public  void setContent(String content) {
              this.content  = content;
       }
       public  Attachment getAttachment(){
              return  (this.attachment);
       }
       public  String getName() {
              return  (this.name);
       }
       public  String getDate() {
              return  (this.date);
       }
       public  String getContent() {
              return  (this.content);
       }
      //使用序列化技术实现深克隆
       public WeeklyLog deepClone() throws  IOException, ClassNotFoundException, OptionalDataException {
              //将对象写入流中 使用了装饰器模式
              ByteArrayOutputStream bao=new  ByteArrayOutputStream();
              ObjectOutputStream oos=new  ObjectOutputStream(bao);
              oos.writeObject(this);

              //将对象从流中取出
              ByteArrayInputStream bis=new  ByteArrayInputStream(bao.toByteArray());
              ObjectInputStream ois=new  ObjectInputStream(bis);
              return  (WeeklyLog)ois.readObject();
       }
}

重新编译程序，得到如下结果：

周报是否相同？  false
附件是否相同？  false

从输出结果可以看出，由于使用了深克隆技术，附件对象也得以复制，因此用“==”比较原型对象的附件和克隆对象的附件时输出结果均为 false。深克隆技术实现了原型对象和克隆对象的完全独立，对任意克隆对象的修改都不会给其他对象产生影响，是一种更为理想的克隆实现方式。

拓展：
Java 语言提供的 Cloneable 接口和 Serializable 接口的代码非常简单，它们都是空接口，这种空接口也称为标识接口，标识接口中没有任何方法的定义，其作用是告诉 JRE 这些接口的实现类是否具有某个功能，如是否支持克隆、是否支持序列化等。