java中的深克隆和浅克隆

在Java中，如果想要快速的复制一个当前对象的拷贝，最好的方法是实现Cloneable接口，官方提供的API文档中，对Cloneable的描述是“Creates and returns a copy of this object.”，翻译过来即为“创建并返回一个对象的拷贝”。
实现Cloneable接口也很简单，继承Cloneable接口，然后重写clone方法即可。比如我们要复制下面这个类，就可以这么写：

class Staff implements Cloneable{
    String name;
    int age;

    public Staff(String name, int age) {
            this.name = name;
            this.age = age;
    }

    public Object clone() {
        Object o = null;
        try {
            o = (Object)super.clone(); //此处实现clone
        } catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }

    public String toString() { //为了打印信息方便
        return "Name is " + name + ",age is " + age;
    }

}

我们再写个测试类看看是否完成了克隆：

class Test {
    public static void main(String[] args) {

        Staff zhangsan = new Staff("zhangsan", 20);
        Staff lisi = (Staff)zhangsan.clone();

        System.out.println("Staff zhangsan info:" + zhangsan.toString());
        System.out.println("Staff lisi info:" + lisi.toString());

        lisi.name = "lisi";
        lisi.age = 25;
        System.out.println("Staff zhangsan info:" + zhangsan.toString());
        System.out.println("Staff lisi info:" + lisi.toString());
    }
}

我们先分析一下结果，我们通过创建员工张三，然后clone一份后赋值给lisi，那么第一次打印的结果应该都是张三的信息，之后我们修改lisi的信息，这样第二次打印出来的李四的信息应该和张三不同，有兴趣的朋友可以自己试试运行结果，我先贴出效果图：

好的，没有问题，张三和李四的信息一开始是相同的，因为clone会完全复制一份原对象的拷贝，更改之后互相之间也没有影响。看起来java中的克隆很简单啊，我们来回忆一下步骤：
1.继承Cloneable接口
2.实现clone方法。
就这么两步完成了！等等，标题不是有深克隆和浅克隆吗？怎么什么都没讲啊！别急，我们先稍微改改代码，如果每个员工中增加一个成员Boss，我们看看会有什么变化，先上代码:

class Staff implements Cloneable{
    String name;
    int age;
    Boss boss; //增加的属性Boss

    public Staff(String name, int age, Boss boss) {
            this.name = name;
            this.age = age;
            this.boss = boss;
    }

    public Object clone() {
        Object o = null;
        try {
            o = (Object)super.clone(); //此处实现clone
        } catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }

    public String toString() {
        return "Name is " + name + ",age is " + age + "\n his boss is:" + boss.toString(); //把BOSS的信息也打印出来
    }

}

class Boss { //每个员工都需要一个Boss
    String name;
    int age;

    public Boss(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return "Name is " + name + ",age is " + age;
    }

}

class Test {
    public static void main(String[] args) {

        Boss wangwu = new Boss("wangwu", 40); //创建第一个Boss，王五

        Staff zhangsan = new Staff("zhangsan", 20, wangwu);
        Staff lisi = (Staff)zhangsan.clone();

        System.out.println("Staff zhangsan info:" + zhangsan.toString());
        System.out.println("Staff lisi info:" + lisi.toString());

        lisi.name = "lisi";
        lisi.age = 25;
        lisi.boss.name = "zhaoliu"; //修改一下李四的Boss，改成赵六
        lisi.boss.age = 50;
        System.out.println("Staff zhangsan info:" + zhangsan.toString());
        System.out.println("Staff lisi info:" + lisi.toString());
    }
}

思路和刚刚的代码一样，李四由张三克隆而来，再把李四的信息修改一下，把李四的Boss也修改一下，这次看看运行效果：

这是怎么回事？怎么我修改李四的Boss，结果把张三的Boss也修改了。
Java中，拷贝对象是其实拷贝的是变量的值，对于引用对象，例如staff中的Boss对象，它并不是将Boss中的name和age都拷贝了一份，而只是在将张三的boss的值复制了一份，而张三中boss的值存储的其实是Boss王五的引用，所以，李四的boss其实和张三的boss都指向了内存中的同一块区域，修改李四的，张三的也受到了影响。下面这张图能直观的展示

可以看到，两个员工其实指向的都是Boss王五的内存区域，所以修改李四的Boss也将张三的Boss修改了。
上述情况显然不是我们所希望的：如果我们在复制对象之后，操作复制后的对象结果还将原对象修改了，这个恐怕会产生一些奇怪的Bug，那么这个时候就需要用到深克隆了。
其实深克隆也很简单，我们来想想上述问题产生的原因是什么，拷贝Staff的时候由于其成员Boss也是一个引用类型的变量，所以引用的地址重复了，这个时候其实只要让Boss也继承自Cloneable接口即可，话不多说，先看看代码：

class Staff implements Cloneable{
    String name;
    int age;
    Boss boss;

    public Staff(String name, int age, Boss boss) {
            this.name = name;
            this.age = age;
            this.boss = boss;
    }

    public Object clone() {
        Staff o = null;
        try {
            o = (Staff)super.clone();
            o.boss = (Boss)boss.clone(); //这里Boss对象也clone了一份，引用的内存不再是同一块内存，问题解决了。
        } catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }

    public String toString() {
        return "Name is " + name + ",age is " + age + "\n his boss is:" + boss.toString();
    }

}

class Boss implements Cloneable {
    String name;
    int age;

    public Boss(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return "Name is " + name + ",age is " + age;
    }

    public Object clone() {
        Object o = null;
        try {
            o = super.clone();
        } catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }

}

这个时候再看看运行结果：

搞定，张三的Boss仍然是王五，李四的Boss变成了赵六，深拷贝成功了！

等等，细心的你是不是已经注意到了，name是个String的对象，拷贝的时候其实也是拷贝了引用地址，指向的是同一块内存，怎么不需要clone呢？这个问题我暂时不给出解答，留给聪明的你来解决了！