Java 对象的克隆Clone和必须了解的浅拷贝与深拷贝

前言

为什么要写这篇文章？

因为我最近无意间看到了一些项目的代码，不管是曾经编码的人还是新接手的人， 在想完全克隆复制一个已经存在的对象，做为后续的使用，竟然都是采取了重写new一个，然后一个个属性字段值get出来再set回去，这种代码段让我不禁陷入了沉思。

简单描述下场景：

已经存在一个对象  sheep，里面已经有了一些字段属性值；

因为业务处理需要，想整一个跟这个sheep 对象一模一样的 sheep2 出来；

然后在不管是使用sheep 或者 sheep2 的时候，都互不干扰。

正文

那么实现这个场景，最简单最高效的方法是什么呢？

那就是使用克隆 clone。

ps： 当然不妨可能有一些粗心大意的人或者是新手来说，还会写出以下这种代码，这里不多言。

那么接下来进入正题，clone 克隆的使用。

在结合代码介绍clone前， 必须要先列出一些概念理论知识。

1. 我们使用的 clone（）方法，来自于 java类 Object ，也就是所有的java类都继承的java.lang.Object ，用的就是Object里面的clone（）。

2. 使用clone（）拷贝出来的对象，有自己新的内存地址，而不是跟被拷贝对象一样指向同一个内存地址。

3.使用clone（）拷贝对象跟new 对象的区别是，new是出来一个初始化新对象，而clone是复制出来一个包含原对象一些信息数据的新对象。

结合实例：

要使用clone（），那么类就需要实现 Cloneable 接口。

如：

那么可能有的人就发现了，实现了这个Cloneable，编辑工具没有提示我们去重写方法之类的？？

或是动手能力强的人，点进去了Object的clone方法源码里面，发现是一个空方法？？

简短地解惑：

关键在于，native这个关键字，使用这个关键字修饰的方法（如果平时有多点源码的，应该对这个关键字不陌生），代表这个方法实现体被调用，是告知 jvm去调用非java代码编写的实现体，例如C语言编写的等。而 jvm能否去调用这个实现体，也就是根据咱们是否有实现了Cloneable这个接口做为标记。

（可以看看设计者在Cloneable留下来的注释，多看源码肯定是有益的。） 

好了，不啰嗦，咱们要在Sheep.java 类上使用clone（）方法去实现克隆。
我们需要就是实现Cloneable接口，以及重写clone方法，而且把重写的clone方法的protected  改完 public 。

如：

public class Sheep implements Cloneable {

    private String name;
    private Integer age;


    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

仅到此，我们来写个测试方法，试一下克隆一个sheep对象,生成 sheep2对象：

    public static void main(String[] args) throws CloneNotSupportedException {

        Sheep sheep=new Sheep();
        sheep.setName("merry");
        sheep.setAge(5);

        System.out.println("克隆前 sheep :"+sheep.toString());
        System.out.println("-----进行克隆-----");

        Sheep sheep2 = (Sheep) sheep.clone();

        System.out.println("克隆出来的 sheep2:" +sheep2.toString());
        System.out.println("sheep 与 sheep2 的内存地址是否一样 ： "+ (sheep2==sheep));

        sheep2.setName(" update from sheep2");

        System.out.println("修改 sheep2 的name后, sheep："+sheep.toString());

        System.out.println("修改 sheep2 的name后, sheep2："+sheep2.toString());
    }

可以看到结果：

到这里是否就认为clone的使用就这样子ok了呢？

确实，如果你需要进行克隆的对象里面，只包含基本变量的话，这种clone的使用确实已经足够了。

但是如果里面包含的不只是基本变量，还存在其他对象的引用，那么就涉及到了深拷贝与浅拷贝的知识。

深拷贝  与  浅拷贝

在我们结合代码实例前，我们先了解下这个深拷贝，浅拷贝的概念理论知识：

浅拷贝： 指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。

深拷贝 ：深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。

这么一看，是不是发现了我们上面的例子里面，其实就是属于浅拷贝，确实如此。

因为对于clone方法来说，

如果不对clone（）方法进行改造，那么默认的使用，都是浅拷贝。

结合实例：

可见现在的sheep类里已经除了基本变量还包含了额外的对象引用 Wool

Wool.java

那么基于这种情况，我们来试试此时浅拷贝克隆出来的情景：

    public static void main(String[] args) throws CloneNotSupportedException {

        Wool wool=new Wool();
        wool.setColor("Red Red Red Red");

        Sheep sheep=new Sheep();
        sheep.setName("merry");
        sheep.setAge(5);
        sheep.setWool(wool);
        System.out.println("克隆前 sheep :"+sheep.toString());
        System.out.println("-----进行克隆-----");
        Sheep sheep2 = (Sheep) sheep.clone();
        System.out.println("克隆出来的 sheep2:" +sheep2.toString());

        System.out.println("------对sheep2的Wool 颜色属性进行修改------");
        sheep2.getWool().setColor("Black Black  Black");

        System.out.println("修改 wool颜色后, sheep："+sheep.toString());

        System.out.println("修改 wool颜色后,, sheep2："+sheep2.toString());
    }

结果：

为什么？

因为这是浅度拷贝，对除了基本变量的属性值复制外，对里面的wool对象引用并没有额外分配新的内存地址，所以一旦修改了wool，无论是修改sheep的wool属性还是sheep2的属性， 都会致使 使用到wool对象的对象实例 受影响。

所以对于这种实例里面包含了其他对象的引用，在我们使用克隆clone方法时，我们需要对clone（）进行改造，实现深拷贝。

这样不管后续怎么去修改，克隆出来的对象与被克隆的对象都互不干扰。

进行改造，如上面的分析，我们需要在对Sheep进行克隆的时候，对里面的Wool也分配新的内存地址。

所以：

改造步骤1，让Wool也实现Cloneable，里面wool的重写的clone方法来进行新的内存地址划分。

改造步骤2，在Sheep的clone方法里，调用wool的clone方法然后再赋值。

具体代码:

步骤1

Wool.java

public class Wool  implements Cloneable{

    private String color;


    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Wool{" +
                "color='" + color + '\'' +
                '}';
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

步骤2：

Sheep.java

public class Sheep implements Cloneable {

    private String name;
    private Integer age;
    private Wool wool;

    @Override
    public Object clone() throws CloneNotSupportedException {

        Sheep sheep= (Sheep) super.clone();
        sheep.wool= (Wool) wool.clone();
        return sheep;
    }

    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", wool=" + wool +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Wool getWool() {
        return wool;
    }

    public void setWool(Wool wool) {
        this.wool = wool;
    }
}

Sheep的clone方法改造分析：

测试方法：

    public static void main(String[] args) throws CloneNotSupportedException {

        Wool wool=new Wool();
        wool.setColor("Red Red Red Red");

        Sheep sheep=new Sheep();
        sheep.setName("merry");
        sheep.setAge(5);
        sheep.setWool(wool);
        System.out.println("克隆前 sheep :"+sheep.toString());
        System.out.println("-----进行克隆-----");
        Sheep sheep2 = (Sheep) sheep.clone();
        System.out.println("克隆出来的 sheep2:" +sheep2.toString());

        System.out.println("------对sheep2的Wool 颜色属性进行修改------");
        sheep2.getWool().setColor("Black Black  Black");

        System.out.println("修改 wool颜色后, sheep："+sheep.toString());

        System.out.println("修改 wool颜色后,, sheep2："+sheep2.toString());
    }
}

测试结果：

ps： 深拷贝，大家理解意思后，其实应该清楚，实现的方式很多种，那么还有哪些方式实现呢？ 不妨自己探索下。

好了，该篇就到此。