对象的克隆clone

克隆，也叫复制，包括：深克隆、浅克隆（深复制或浅复制）。java的clone()方法定义在Object类中，克隆方法将对象复制一份返回给调用者。

一般而言：

1、对任意的对X象，都有X.clone() ！= X；

克隆对象与原对象不是一个对象

2、对任何对象X，都有X.getClass == X.clone().getClass()；

克隆对象与原对象的类型一样

3、如果X的equals()方法定义恰当，那么X.clone().equals(X)应该成立。

【浅复制】

被复制的所有变量都与原来对象中的变量有相同的值，而所有的对其他对象的引用仍指向原来的对象。如图：

【深复制】

被复制的所有变量都与原来对象中的变量有相同的值，而所有的对其他对象的引用指向原来的对象所复制的一份新对象。如图：

克隆的准备条件：

1、要被克隆的对象必须implements Cloneable；

2、复写Object类中的clone()方法，Object类中的clone()方法是protected类型的，在复写时要改成public类型的；

3、在复写的clone()方法中，第一行写super.clone();原因如下：

通过调用super.clone();在运行时，Object类的clone()方法会自动识别出要复制的是哪个对象，然后为此对象分配空间，将原始对象中的内容一一复制到新对象的存储空间中。

注意：继承Object类中的clone()方法是浅复制。

深克隆、浅克隆示例

【浅克隆】

package com.lpp.clone;

public class CloneDemo
{
    public static void main(String[] args) throws Exception
    {
        Children c = new Children();
        c.setAge(16);
        c.setName("children1");
        
        Person p = new Person();
        p.setAge(28);
        p.setName("lpp");
        p.setChildren(c);
        
        Person p2 = (Person)p.clone();
        //打印新对象中的内容
        System.out.println(p2.getName()+":"+p2.getAge());
        System.out.println(p2.getChildren().getName()+":"+p2.getChildren().getAge());
        
        System.out.println("--------------------");
        
        p2.getChildren().setName("children2");//修改新对象中的Children引用
        p2.getChildren().setAge(17);
        //打印原对象中的内容
        System.out.println(p.getName()+":"+p.getAge());
        System.out.println(p.getChildren().getName()+":"+p.getChildren().getAge());
        //打印新对象中修改了Children的内容
        System.out.println(p2.getName()+":"+p2.getAge());
        System.out.println(p2.getChildren().getName()+":"+p2.getChildren().getAge());
    }
}
class Person implements Cloneable//实现Cloneable接口
{
    int age;
    String name;
    Children children;
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public Children getChildren()
    {
        return children;
    }
    public void setChildren(Children children)
    {
        this.children = children;
    }
    @Override
    public Object clone() throws CloneNotSupportedException//访问权限修改成public
    {
        return super.clone();
    }
    
}
class Children
{
    int age;
    String name;
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    
}

结果：

lpp:28
children1:16
--------------------
lpp:28
children2:17
lpp:28
children2:17

可见，修改了新对象中的Chiledren引用所指向的内容，原对象和新对象中Children的内容都会改变，这就证实了浅克隆中，对象中对其他对象的引用所指向的内容没有被复制，始终只有一份。

【深克隆】

对上述代码做如下改变：

class Person implements Cloneable//实现Cloneable接口
{
    int age;
    String name;
    Children children;
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public Children getChildren()
    {
        return children;
    }
    public void setChildren(Children children)
    {
        this.children = children;
    }
    @Override
    public Object clone() throws CloneNotSupportedException//访问权限修改成public
    {
        Person p = (Person)super.clone();
        p.setChildren((Children)(p.getChildren().clone()));//克隆p中的Children
        return p;
    }
    
}
class Children implements Cloneable//实现Cloneable接口
{
    int age;
    String name;
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    @Override
    public Object clone() throws CloneNotSupportedException//访问权限修改成public
    {
        return super.clone();
    }
}

结果：

lpp:28
children1:16
--------------------
lpp:28
children1:16
lpp:28
children2:17

可知，克隆了Person中的Children后，Person中的Children引用指向一个新的Children，因此修改新的Children，不会对原来的Children有影响。

另一种实现深克隆的方法为将要克隆的内容进行序列化，然后再通过反序列化，将缓存中的内容读回来，应该强调的是写在流里的是原对象的一个拷贝，原对象还保存在JVM里面。这样做的前提是对象及所引用的对象都是可序列化的，否则应考虑将不可序列化的对象设为用transien，将其排除在序列化之外。

【利用序列化实现深克隆】

package com.lpp.clone;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class SerializableClone
{
    public static void main(String[] args) throws Exception
    {
        Student s = new Student();
        s.setAge(12);
        s.setName("student1");
        
        Teacher t = new Teacher();
        t.setAge(28);
        t.setName("lpp");
        t.setStudent(s);
        
        Teacher t2 = (Teacher)t.deepClone();
        //打印新对象中的内容
        System.out.println(t2.getName()+":"+t2.getAge());
        System.out.println(t2.getStudent().getName()+":"+t2.getStudent().getAge());
        
        System.out.println("--------------------");
        
        t2.getStudent().setName("student2");//修改新对象中的Children引用
        t2.getStudent().setAge(13);
        //打印原对象中的内容
        System.out.println(t.getName()+":"+t.getAge());
        System.out.println(t.getStudent().getName()+":"+t.getStudent().getAge());
        //打印新对象中修改了Children的内容
        System.out.println(t2.getName()+":"+t2.getAge());
        System.out.println(t2.getStudent().getName()+":"+t2.getStudent().getAge());
    }
}
class Teacher implements Serializable//实现Serializable接口而不是Cloneable接口
{
    int age;
    String name;
    Student student;
    
    public int getAge()
    {
        return age;
    }

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

    public String getName()
    {
        return name;
    }

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

    public Student getStudent()
    {
        return student;
    }

    public void setStudent(Student student)
    {
        this.student = student;
    }

    public Object deepClone() throws Exception
    {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);//把当前对象的拷贝写到流里，进行序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();//从当前流里读取对象拷贝，进行反序列化
        
    }
    
}
class Student implements Serializable//实现Serializable接口而不是Cloneable接口
{
    int age;
    String name;
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    
}

结果：

lpp:28
student1:12
--------------------
lpp:28
student1:12
lpp:28
student2:13

可见通过序列化，实现了对象的深度拷贝。这是实现深克隆的最好的办法。