对象的克隆——原型模式（三）

7.4 带附件的周报

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

在回答这些问题之前，先介绍一下两种不同的克隆方法，浅克隆(ShallowClone)和深克隆(DeepClone)。在Java语言中，数据类型分为值类型（基本数据类型）和引用类型，值类型包括int、double、byte、boolean、char等简单数据类型，引用类型包括类、接口、数组等复杂类型。浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制，下面将对两者进行详细介绍。

1.浅克隆

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

对象的克隆——原型模式（三） - 图1

图7-4 浅克隆示意图

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

对象的克隆——原型模式（三） - 图2

图7-5 带附件的周报结构图（浅克隆）

附件类Attachment代码如下：

  1. //附件类
  2. class Attachment
  3. {
  4.        private  String name; //附件名
  5.        public  void setName(String name)
  6.        {
  7.               this.name  = name;
  8.        }
  9.        public  String getName()
  10.        {
  11.               return  this.name;
  12.        }
  13.      public void download()
  14.      {
  15.             System.out.println("下载附件，文件名为" + name);
  16.      }
  17. }

修改工作周报类WeeklyLog，修改后的代码如下：

  1. //工作周报WeeklyLog
  2. class WeeklyLog implements Cloneable
  3. {
  4.      //为了简化设计和实现，假设一份工作周报中只有一个附件对象，实际情况中可以包含多个附件，可以通过List等集合对象来实现
  5.        private Attachment attachment;
  6. private String name;
  7.        private  String date;
  8.        private  String content;
  9.     public void setAttachment(Attachment  attachment) {
  10.               this.attachment = attachment;
  11.        }
  12.        public  void setName(String name) {
  13.               this.name  = name;
  14.        }
  15.        public  void setDate(String date) {
  16.               this.date  = date;
  17.        }
  18.        public  void setContent(String content) {
  19.               this.content  = content;
  20.        }
  21. public Attachment  getAttachment(){
  22.               return (this.attachment);
  23.        }
  24.        public  String getName() {
  25.               return  (this.name);
  26.        }
  27.        public  String getDate() {
  28.               return  (this.date);
  29.        }
  30.        public  String getContent() {
  31.               return  (this.content);
  32.        }
  33.      //使用clone()方法实现浅克隆
  34.        public WeeklyLog clone()
  35.        {
  36.               Object obj = null;
  37.               try
  38.               {
  39.                      obj = super.clone();
  40.                      return (WeeklyLog)obj;
  41.               }
  42.               catch(CloneNotSupportedException  e)
  43.               {
  44.                      System.out.println("不支持复制！");
  45.                      return null;
  46.               }
  47.        }
  48. }

客户端代码如下所示：

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

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

  1. 周报是否相同？  false
  2. 附件是否相同？ true

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

2.深克隆

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

对象的克隆——原型模式（三） - 图3

图7-6 深克隆示意图

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

对象的克隆——原型模式（三） - 图4

图7-7 带附件的周报结构图（深克隆）

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

  1. import  java.io.*;
  2. //附件类
  3. class  Attachment implements Serializable
  4. {
  5.        private  String name; //附件名
  6.        public  void setName(String name)
  7.        {
  8.               this.name  = name;
  9.        }
  10.        public  String getName()
  11.        {
  12.               return  this.name;
  13.        }
  14.      public void download()
  15.      {
  16.             System.out.println("下载附件，文件名为" + name);
  17.      }
  18. }

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

  1. import  java.io.*;
  2. //工作周报类
  3. class  WeeklyLog implements Serializable
  4. {
  5.        private  Attachment attachment;
  6.        private  String name;
  7.        private  String date;
  8.        private  String content;
  9.        public  void setAttachment(Attachment attachment) {
  10.               this.attachment  = attachment;
  11.        }
  12.        public  void setName(String name) {
  13.               this.name  = name;
  14.        }
  15.        public  void setDate(String date) {
  16.               this.date  = date;
  17.        }
  18.        public  void setContent(String content) {
  19.               this.content  = content;
  20.        }
  21.        public  Attachment getAttachment(){
  22.               return  (this.attachment);
  23.        }
  24.        public  String getName() {
  25.               return  (this.name);
  26.        }
  27.        public  String getDate() {
  28.               return  (this.date);
  29.        }
  30.        public  String getContent() {
  31.               return  (this.content);
  32.        }
  33.    //使用序列化技术实现深克隆
  34.        public WeeklyLog deepClone() throws  IOException, ClassNotFoundException, OptionalDataException
  35.        {
  36.               //将对象写入流中
  37.               ByteArrayOutputStream bao=new  ByteArrayOutputStream();
  38.               ObjectOutputStream oos=new  ObjectOutputStream(bao);
  39.               oos.writeObject(this);
  41.               //将对象从流中取出
  42.               ByteArrayInputStream bis=new  ByteArrayInputStream(bao.toByteArray());
  43.               ObjectInputStream ois=new  ObjectInputStream(bis);
  44.               return  (WeeklyLog)ois.readObject();
  45.        }
  46. }

客户端代码如下所示：

  1. class Client
  2. {
  3.        public  static void main(String args[])
  4.        {
  5.               WeeklyLog  log_previous, log_new = null;
  6.               log_previous  = new WeeklyLog(); //创建原型对象
  7.               Attachment  attachment = new Attachment(); //创建附件对象
  8.               log_previous.setAttachment(attachment);  //将附件添加到周报中
  9.               try
  10.               {
  11.                      log_new =  log_previous.deepClone(); //调用深克隆方法创建克隆对象                  
  12.               }
  13.               catch(Exception e)
  14.               {
  15.                      System.err.println("克隆失败！");
  16.               }
  17.               //比较周报
  18.               System.out.println("周报是否相同？ " + (log_previous ==  log_new));
  19.               //比较附件
  20.               System.out.println("附件是否相同？ " +  (log_previous.getAttachment() == log_new.getAttachment()));
  21.        }
  22. }

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

  1. 周报是否相同？  false
  2. 附件是否相同？  false

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

扩展

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