浅克隆和深克隆

一、浅克隆(ShallowClone)

在浅克隆中，如果原型对象的成员变量是值类型，将复制一份给克隆对象；如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。

简单来说，在浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。

二、深克隆(DeepClone)

在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对象。

简单来说，在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量也将复制。

Java 中，如果需要实现深克隆，可以通过覆盖 Object 类 的 clone() 实现，也可以通过序列化(Serialization)等方式来实现。

如果引用类型里面还包含很多引用类型，或者内层引用类型的类里面又包含引用类型，使用 clone 方法就会很麻烦。这时可以用序列化的方式来实现对象的深克隆。

序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个拷贝，而原对象仍然存在于内存中。通过序列化实现的拷贝不仅可以复制对象本身，而且可以复制其引用的成员对象，因此通过序列化将对象写到一个流中，再从流里将其读出来，可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现 Serializable 接口，否则无法实现序列化操作。

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

三、解决多层克隆问题

public class Outer implements Serializable{
  private static final long serialVersionUID = 369285298572941L;  //最好是显式声明ID
  public Inner inner;
　//Discription:[深度复制方法,需要对象及对象所有的对象属性都实现序列化]
  public Outer myclone() {
      Outer outer = null;
      try {
//将该对象序列化成流，因为写在流里的是对象的一个拷贝，
//而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          ObjectOutputStream oos = new ObjectOutputStream(baos);
          oos.writeObject(this);
　　　　　　// 将流序列化成对象
          ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
          ObjectInputStream ois = new ObjectInputStream(bais);
          outer = (Outer) ois.readObject();
      } catch (IOException e) {
          e.printStackTrace();
      } catch (ClassNotFoundException e) {
          e.printStackTrace();
      }
      return outer;
  }
}

Inner 也必须实现 Serializable，否则无法序列化：

public class Inner implements Serializable{
  private static final long serialVersionUID = 872390113109L; //最好是显式声明ID
  public String name = "";
  public Inner(String name) {
      this.name = name;
  }
  @Override
  public String toString() {
      return "Inner的name值为：" + name;
  }
}

这样也能使两个对象在内存空间内完全独立存在，互不影响对方的值。

四、理解

假如说想复制一个简单变量。很简单：

int apples = 5;
int pears = apples;

不仅仅是 int 类型，其它七种基础数据类型(byte、short、char、long、float、double、boolean)同样适用于该类情况。但是如果复制的是一个对象，情况就有些复杂了：

class Student {
    private int number;
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
}
public class Test {
    public static void main(String args[]) {
        Student stu1 = new Student();
        stu1.setNumber(12345);
        Student stu2 = stu1;
        System.out.println("学生1：" + stu1.getNumber());
        System.out.println("学生2：" + stu2.getNumber());
    }  
}

结果：
学生1：12345
学生2：12345

试着改变 stu2 实例的 number 字段，再打印结果看看：

stu2.setNumber(54321);
System.out.println("学生1：" + stu1.getNumber()); 
System.out.println("学生2：" + stu2.getNumber());

结果：
学生1：54321
学生2：54321

这就怪了，为什么改变学生 2 的学号，学生 1 的学号也发生了变化呢？原因出在stu2 = stu1这一句。该句的作用是将 stu1 的引用赋值给 stu2，这样 stu1 和 stu2 就指向内存堆中同一个对象。如图：

那么，怎样才能复制一个对象呢？Object。它有 11 个方法，有两个 protected 的方法，其中一个为 clone 方法。Java 中所有的类都是缺省的继承 Object 类的，查看源码，发现有一个 protected 的方法 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 x, the expression:
1) x.clone() != x will be true
2) x.clone().getClass() == x.getClass() will be true, but these are not absolute requirements.
3) x.clone().equals(x) will be true, this is not an absolute requirement.
*/
protected native Object clone() throws CloneNotSupportedException;

它是一个 native 方法，native 方法是非 Java 语言实现的代码，供 Java 程序调用的，因为 Java 程序是运行在 JVM 虚拟机上面的，要想访问到比较底层的与操作系统相关的就没办法了，只能由靠近操作系统的语言来实现。

  1. 第一次声明，保证克隆对象将有单独的内存地址分配。
  2. 第二次表明，原始和克隆的对象应该具有相同的类类型，但它不是强制性的。
  3. 第三次表明，原始和克隆的对象应该是平等的 equals() 使用，但它不是强制性的。

因为每个类直接或间接的父类都是 Object，因此它们都含有 clone()，但是因为该方法是 protected，所以都不能在类外进行访问。要想对一个对象进行复制，就需要对 clone 方法覆盖。

五、为什么需要克隆对象？直接new一个对象不行吗？

克隆的对象可能包含一些已经修改过的属性，而 new 出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠 clone 方法了。那么把这个对象的临时属性一个一个的赋值给新 new 的对象不也行嘛？可以，但是麻烦。况且源码里 clone 是一个 native 方法，极其方便。

Object a=new Object();
Object b;
b=a;

这种形式的代码复制的是引用，即对象在内存中的地址，a 和 b 对象仍然指向了同一个对象。而通过 clone 方法赋值的对象跟原来的对象时同时独立存在的。

六、如何实现克隆

Java中，数据类型分为值类型(基本数据类型)和引用类型。值类型包括 byte、short、char、int、long、float、double、boolean 简单数据类型；引用类型包括类、接口、数组等复杂类型。浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制，下面将对两者进行详细介绍。

1️⃣浅克隆

  1. 被复制的类需要实现 Clonenable 接口(不实现的话在调用 clone 方法会抛出 CloneNotSupportedException)，该接口为标记接口(不含任何方法)。
  2. 覆盖 clone()，访问修饰符设为 public。方法中调用 super.clone() 得到需要复制的对象。(native 为本地方法)

下面对上面那个方法进行改造：

class Student implements Cloneable{  
    private int number;  
    public int getNumber() {  
        return number;  
    }  
    public void setNumber(int number) {  
        this.number = number;  
    }  
      
    @Override  
    public Object clone() {  
        Student stu = null;  
        try{  
            stu = (Student)super.clone();  
        }catch(CloneNotSupportedException e) {  
            e.printStackTrace();  
        }  
        return stu;  
    }  
}  
public class Test {  
    public static void main(String args[]) {  
        Student stu1 = new Student();  
        stu1.setNumber(12345);  
        Student stu2 = (Student)stu1.clone();  
          
        System.out.println("学生1:" + stu1.getNumber());  
        System.out.println("学生2:" + stu2.getNumber());  
          
        stu2.setNumber(54321);  
      
        System.out.println("学生1:" + stu1.getNumber());  
        System.out.println("学生2:" + stu2.getNumber());  
        System.out.println(stu1 == stu2); // false
    }  
}

结果：
学生1:12345
学生2:12345
学生1:12345
学生2:54321
false -----说明这两个对象不是同一个对象

2️⃣深克隆

在学生类里再加一个 Address 类。

class Address  {
    private String add;
    public String getAdd() {
        return add;
    }
    public void setAdd(String add) {
        this.add = add;
    }
}

class Student implements Cloneable{
    private int number;
    private Address addr;
    public Address getAddr() {
        return addr;
    }
    public void setAddr(Address addr) {
        this.addr = addr;
    }
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }

    @Override
    public Object clone() {
        Student stu = null;
        try{
            stu = (Student)super.clone();
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return stu;
    }
}

public class Test {
    public static void main(String args[]) {
        Address addr = new Address();
        addr.setAdd("杭州市");
        Student stu1 = new Student();
        stu1.setNumber(123);
        stu1.setAddr(addr);
        Student stu2 = (Student)stu1.clone();
        System.out.println("学生1：" + stu1.getNumber() + "，地址：" + stu1.getAddr().getAdd());
        System.out.println("学生2：" + stu2.getNumber() + "，地址：" + stu2.getAddr().getAdd());
    }
}

结果：
学生1：123，地址：杭州市
学生2：123，地址：杭州市

在 main 方法中试着改变 addr 实例的地址：

addr.setAdd("西湖区");  
System.out.println("学生1：" + stu1.getNumber() + "，地址：" + stu1.getAddr().getAdd());
System.out.println("学生2：" + stu2.getNumber() + "，地址：" + stu2.getAddr().getAdd());

结果：
学生1：123，地址：杭州市
学生2：123，地址：杭州市
学生1：123，地址：西湖区
学生2：123，地址：西湖区

原因是浅复制只是复制了 addr 变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象。所以，为了达到真正的复制对象，而不是纯粹引用复制。需要将 Address 类可复制化，并且修改 clone 方法，完整代码如下：

class Address implements Cloneable {
    private String add;
    public String getAdd() {
        return add;
    }
    public void setAdd(String add) {
        this.add = add;
    }

    @Override
    public Object clone() {
        Address addr = null;
        try{
            addr = (Address)super.clone();
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return addr;
    }
}

class Student implements Cloneable{
    private int number;
    private Address addr;
    public Address getAddr() {
        return addr;
    }
    public void setAddr(Address addr) {
        this.addr = addr;
    }
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }

    @Override
    public Object clone() {
        Student stu = null;
        try{
            stu = (Student)super.clone();   //浅复制
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        stu.addr = (Address)addr.clone();   //深度复制
        return stu;
    }
}
public class Test {
    public static void main(String args[]) {
        Address addr = new Address();
        addr.setAdd("杭州市");
        Student stu1 = new Student();
        stu1.setNumber(123);
        stu1.setAddr(addr);
        Student stu2 = (Student)stu1.clone();
        System.out.println("学生1：" + stu1.getNumber() + "，地址：" + stu1.getAddr().getAdd());
        System.out.println("学生2：" + stu2.getNumber() + "，地址：" + stu2.getAddr().getAdd());
        addr.setAdd("西湖区");
        System.out.println("学生1：" + stu1.getNumber() + "，地址：" + stu1.getAddr().getAdd());
        System.out.println("学生2：" + stu2.getNumber() + "，地址：" + stu2.getAddr().getAdd());
    }
}

结果：
学生1：123，地址：杭州市
学生2：123，地址：杭州市
学生1：123，地址：西湖区
学生2：123，地址：杭州市

最后可以看看 API 里其中一个实现了 clone 方法的类：java.util.Date:

/** 
 * Return a copy of this object. 
 */  
public Object clone() {  
    Date d = null;  
    try {  
        d = (Date)super.clone();  
        if (cdate != null) {  
            d.cdate = (BaseCalendar.Date) cdate.clone();  
        }  
    } catch (CloneNotSupportedException e) {} // Won't happen  
    return d;  
}

该类其实也属于深度复制。

七、总结

实现对象克隆有两种方式：
1️⃣实现 Cloneable 接口并重写 Object 类中的 clone()。
2️⃣实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。
3️⃣注意：基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用 Object 类的 clone 方法克隆对象。让问题在编译的时候暴露出来总是优于把问题留到运行时。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 196,165评论 5赞 462
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 82,503评论 2赞 373
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 143,295评论 0赞 325
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,589评论 1赞 267
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,439评论 5赞 358
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,342评论 1赞 273
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,749评论 3赞 387
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,397评论 0赞 255
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,700评论 1赞 295
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,740评论 2赞 313
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,523评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,364评论 3赞 314
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,755评论 3赞 300
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,024评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,297评论 1赞 251
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,721评论 2赞 342
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,918评论 2赞 336