Java中的克隆

有时候我们需要使用一个对象在某个时刻的状态（比如某个时刻对象中已经被赋值的属性），为了能够保存当时对象的状态，Java出现了克隆的操作。

Java中要想实现克隆，操作十分简单，首先需要实现Cloneable接口，然后重写clone()方法即可。Cloneable接口是一个空接口，它的作用是做标记；clone()方法是一个native方法。

★ 但是最重要的是我们需要明确：

• 当拷贝的对象中含有引用类型属性时，我们在重写clone()方法时除了调用父类中的clone()方法，也需要调用引用类型的clone()方法，这样才能保证克隆后的对象跟原对象完全相互独立，没有任何关联，这也就是所谓的深克隆。

• 如果重写时没有调用引用类型的clone()方法，只是调用父类中的clone()方法，那么两个对象虽然在内存地址上彼此独立，但是对象中的引用类型属性却指向同一个对象，当原对象中的引用类型属性发生变化时，克隆的对象也会跟着发生变化，这就是所谓的浅克隆。

浅克隆

如下代码示例：

public class Car implements Cloneable {
    private String name;

    public Car(String name){
        this.name = name;
    }

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

    public static void main(String[] args) {

        try {
            Car c1 = new Car("Benz");
            Car c2 = (Car) c1.clone();
            System.out.println(c1 == c2);
            System.out.println(c1.name.equals(c2.name));
            System.out.println(c1.name == c2.name);

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }
}

输出结果为：

这段代码实现了对Car对象的一个浅克隆，重写的clone()方法中只是返回了Car的父类clone()方法，String是一个引用类型，因此System.out.println(c1.name == c2.name) 会输出为true，表示原对象跟克隆对象中的String属性指向了同一个字符串。但是String类型是不可变对象域，所以这段代码实现的克隆不会有任何问题。
原理图：

浅克隆适用于对只包含原始数据域或者不可变对象域（比如String类型）的克隆。

深克隆

如下是实现对象深克隆的示例代码：
首先修改引用类型，让它能够进行克隆：

public class Student implements Cloneable{
    private String name;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

}

然后重写本类的clone()方法：

public class School implements Cloneable {
    private int year;
    private Student student;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        School school = (School) super.clone();
        school.student = (Student) student.clone();
        return school;  
    }

}

这样就能够实现对School对象的深克隆。
深克隆适用于对含有引用类型属性的对象的克隆。

多层克隆

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

public class School implements Serializable{

    private static final long serialVersionUID = 1L;
    private Student student;

    public School doClone() {
        School school = null;
        try {
              ByteArrayOutputStream baos = new ByteArrayOutputStream();
              ObjectOutputStream oos = new ObjectOutputStream(baos);
              oos.writeObject(this);

              ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
              ObjectInputStream ois = new ObjectInputStream(bais);
              school = (School) ois.readObject();
          } catch (IOException e) {
              e.printStackTrace();
          } catch (ClassNotFoundException e) {
              e.printStackTrace();
          }
          return school;    
    }

}

School中的引用类型Student也要实现序列化：

public class Student implements Serializable{
    private String name;    
}

这样就可以通过序列化来对对象进行深拷贝。