java克隆

java克隆分为浅克隆和深克隆，概念如下：

浅拷贝（浅克隆）
克隆出来的对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。

深拷贝（深克隆）
克隆出来的所有变量都含有与原来的对象相同的值，那些引用其他对象的变量将指向复制出来的新对象，而不再是原有的那些被引用的对象。换言之，深克隆把要克隆的对象所引用的对象都克隆了一遍。

测试：

​ 接下来我们新建两个实体类，一个为Person类，另一个为Father类，同时实现Clonable接口

Person.java

public class Person implements Cloneable {
    private String name;
    private int age;
    private Father father;

    public Person(String name,int age,Father father){
        this.name = name;
        this.age = age;
        this.father = father;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public Father getFather() {
        return father;
    }

    public void setFather(Father father) {
        this.father = father;
    }
}

Father.java

public class Father implements Cloneable {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

注：这里不能使用lombok注解

测试一：

为Person重写clone方法：

public Person(String name,int age,Father father){
        this.name = name;
        this.age = age;
        this.father = father;
    }

编写测试方法：

Father father = new Father("小明父亲",32);
        Person person = new Person("小明",12,father);

        Person personCloneable = person.clone();
        personCloneable.setAge(1234);
        personCloneable.setName("小刚");
        personCloneable.getFather().setName("小刚父亲");
        System.out.println(person.getName()+":"+person.getAge());
        System.out.println(personCloneable.getName()+":" + personCloneable.getAge());
        System.out.println(person.getFather().getName()+":"+personCloneable.getFather().getName());
        System.out.println(person.getFather() == personCloneable.getFather());

输出结果:

小明:12
小刚:1234
小刚父亲:小刚父亲
true

从测试结果来看person对象的age和name属性成功被克隆，但father属性的引用未变化，因此这是一个浅克隆。

测试二

为Father类重写clone方法：

    @Override
    public Father clone() throws CloneNotSupportedException {
        Father father = null;
        father = (Father) super.clone();
        return father;
    }

为Person类重写clone方法：

    @Override
    public Person clone() throws CloneNotSupportedException {
        Person person = null;
        Father father = this.father.clone();
        person = (Person) super.clone();
        person.setFather(father);
        return person;
    }

再次使用测试一中的测试方法，结果如下：

小明:12
小刚:1234
小明父亲:小刚父亲
false

可以发现此时被克隆的对象的father对象引用和原对象中的father引用不相同，此时我们实现了深克隆。

扩展

如果要克隆的对象继承链比较长的话要实现深克隆，就必须逐层地实现Cloneable，这个过程是比较麻烦的，不过还有一种方法可以简便地实现深克隆。

serializable克隆

PersonSer.java

 private String name;
    private int age;
    private FatherSer father;

    public PersonSer serializableClone() throws IOException, ClassNotFoundException {
        PersonSer person;

        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = new ObjectOutputStream(bo);
        oo.writeObject(this);
        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
        ObjectInputStream oi = new ObjectInputStream(bi);
        person = (PersonSer) oi.readObject();
        return person;
    }

    public PersonSer(String name,int age,FatherSer father){
        this.name = name;
        this.age = age;
        this.father = father;
    }

    @Override
    public Person clone() throws CloneNotSupportedException {
        Person person = null;
        Father father = this.father.clone();
        person = (Person) super.clone();
        person.setFather(father);
        return person;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public FatherSer getFather() {
        return father;
    }

    public void setFather(FatherSer father) {
        this.father = father;
    }

FatherSer.java

public class FatherSer implements Serializable {
    private String name;
    private int age;

    @Override
    public Father clone() throws CloneNotSupportedException {
        Father father = null;
        father = (Father) super.clone();
        return father;
    }


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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

测试类

public static void main(String[] args) throws IOException, ClassNotFoundException {
        FatherSer father = new FatherSer("小明父亲",32);
        PersonSer person = new PersonSer("小明",12,father);

        PersonSer personCloneable = person.serializableClone();
        personCloneable.setAge(1234);
        personCloneable.setName("小刚");
        personCloneable.getFather().setName("小刚父亲");
        System.out.println(person.getName()+":"+person.getAge());
        System.out.println(personCloneable.getName()+":" + personCloneable.getAge());
        System.out.println(person.getFather().getName()+":"+personCloneable.getFather().getName());
        System.out.println(person.getFather() == personCloneable.getFather());

    }

输出结果：

小明:12
小刚:1234
小明父亲:小刚父亲
false

通过把对象写进ByteArrayOutputStream里，再把它读取出来。

注意这个过程中所有涉及的对象都必须实现Serializable接口，由于涉及IO操作，这种方式的效率会比前面的低。