Cloneable接口

Cloneable

Cloneable 接口是一个标记接口,也就是没有任何内容,定义如下:

这里分析一下这个接口的用法，clone 方法是在 Object 种定义的,而且是 protected 型的,只有实现了这个接口，才可以在该类的实例上调用 clone 方法,否则会抛出 CloneNotSupportException。Object 中默认的 实现是一个浅拷贝,也就是表面拷贝,如果需要实现深层次拷贝的话,必须对类中可变域生成新的实例。

---

对象拷贝时，类的构造函数是不会被执行的。

一个实现了 Cloneable 并重写了 clone 方法的类 A,有一个无参构造或有参构造 B，通过 new 关键字产生了一个对象 S，再然后通过 S.clone()方式产生了一个新的对象 T，那么在对象拷贝时构造函数 B 是不会被执行的，我们来写一小段程序来说明这个问题：

public class Thing implements Cloneable {
    public Thing() {
        System.out.println("构造函数被执行了...");
    }

    @Override
    public Thing clone() {
        Thing thing = null;
        try {
            thing = (Thing) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return thing;
    }
}

然后我们再来写一个 Test 类，进行对象的拷贝：

public class Test {
    public static void main(String[] args) {
        //产生一个对象
        Thing thing = new Thing();

        //拷贝一个对象
        Thing cloneThing = thing.clone();
    }
}

运行结果如下：

构造函数被执行了...

对象拷贝时确实构造函数没有被执行，这个从原理来讲也是可以讲得通的，Object 类的 clone 方法的原理是从内存中（具体的说就是堆内存）以二进制流的方式进行拷贝，重新分配一个内存块，那构造函数没有被执行也是非常正常的了。

---

浅拷贝和深拷贝问题

public class Thing implements Cloneable{
        //定义一个私有变量
        private ArrayList<String> arrayList = new ArrayList<String>();
        @Override
        public Thing clone(){
            Thing thing=null;
            try {
                thing = (Thing)super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return thing;
        }

        //设置HashMap的值
        public void setValue(String value){
            this.arrayList.add(value);
        }

        //取得arrayList的值
        public ArrayList<String> getValue(){
            return this.arrayList;
        }

}

在 Thing 类中增加一个私有变量 arrayLis，类型为 ArrayList,然后通过 setValue 和 getValue 分别进行设置和取值，我们来看场景类：

public class Client {
    public static void main(String[] args) {
        //产生一个对象
        Thing thing = new Thing();
        //设置一个值
        thing.setValue("张三");

        //拷贝一个对象
        Thing cloneThing = thing.clone();
        cloneThing.setValue("李四");

        System.out.println(thing.getValue());
    }
}

大家猜想一下运行结果应该是什么？是就一个“张三”吗？运行结果如下：

[张三, 李四]

怎么会有李四呢？是因为 Java 做了一个偷懒的拷贝动作，Object 类提供的方法 clone 只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址，这种拷贝就叫做浅拷贝，确实是非常浅，两个对象共享了一个私有变量，你改我改大家都能改，是一个种非常不安全的方式，在实际项目中使用还是比较少的。你可能会比较奇怪，为什么在 其它类中就可以使用使用 String 类型，而不会产生由浅拷贝带来的问题呢？内部的数组和引用对象才不拷贝，其他的原始类型比如 int,long,String(Java 就希望你把 String 认为是基本类型，String 是没有 clone 方法的)等都会被拷贝的。

解决 clone 的浅拷贝

浅拷贝是有风险的，那怎么才能深入的拷贝呢？我们修改一下我们的程序：

public class Thing implements Cloneable{
    //定义一个私有变量
    private ArrayList<String> arrayList = new ArrayList<String>();
    @Override
    public Thing clone(){
        Thing thing=null;
        try {
            thing = (Thing)super.clone();
            // 新增arrayList.clone()
            thing.arrayList = (ArrayList<String>)this.arrayList.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return thing;
    }
}

仅仅增加了 **thing.arrayList = (ArrayList)this.arrayList.clone();**部分，Client 类没有任何改变，运行结果如下：

[张三]

这个实现了完全的拷贝，两个对象之间没有任何的瓜葛了，你修改你的，我修改我的，不相互影响，这种拷贝就叫做深拷贝，深拷贝还有一种实现方式就是通过自己写二进制流来操作对象，然后实现对象的深拷贝