Java 克隆 （浅克隆/深克隆）

Java中对象的克隆

1.为了获取对象的一份拷贝，我们可以利用Object类的clone()方法

2.在派生类中覆盖基类的clone()方法，并声明为public

3.在派生类的clone()方法中，调用super.clone()

4.在派生类中实现Cloneable接口

public class User implements Cloneable {
    private String name;
    private Integer age;
    public User(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public Object clone() {
        Object object =new Object();
        try {
            //Object中的clone()识别出你要复制的是哪一个对象
            object = (User) super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.toString());
        }
        return object;
    }

    public static void main(String[] args) {
        User u = new User("Henry",20);
        User u2 = (User)u.clone();
        u2.setName("Messi");
        u2.setAge(30);
        System.out.println("name="+u.getName()+","+"age="+u.getAge());
        System.out.println("name="+u2.getName()+","+"age="+u2.getAge());
    }
}

 

1.浅克隆

       被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

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

      比如有一个 Student 类，带有age，name的属性，且引用了 Teacher 类 ，New一个Student 对象 Student_A：

     a、浅克隆会克隆一个新的 Student_B， 但是这个Student_B所引用的Teacher与Student_A的为同一引用。

     b、浅克隆会克隆一个新的 Student_B， 但是这个Student_B所引用的Teacher与Student_A的为不同引用。

 

浅克隆：Student 类实现Cloneable接口，Teacher没有

public class CloneTest
{
	public static void main(String[] args) throws Exception
	{
	Teacher teacher = new Teacher();
	teacher.setAge(40);
	teacher.setName("teacher zhang");
	
	Student student = new Student();
	student.setAge(14);
	student.setName("lisi");
	student.setTeacher(teacher);
		
	Student student2 = (Student)student.clone();
	//这里是深复制，所以这时候Student中的teacher就是teacher这个对象的一个复制，就和student2是student的一个复制
	//所以下面teacher.setName只是对他原来的这个对象更改，但是复制的那个并没有更改
	System.out.println(student2.getAge());
	System.out.println(student2.getName());
	System.out.println(student2.getTeacher().getAge());
	teacher.setName("teacher niesong");//不会又任何影响
	System.out.println(student2.getTeacher().getName());
	
	}
 
}
class Student implements Cloneable
{
	private int age;
	private String name;
	private Teacher teacher;
	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 Teacher getTeacher()
	{
		return teacher;
	}
	public void setTeacher(Teacher teacher)
	{
		this.teacher = teacher;
	}
	@Override
	public Object clone() throws CloneNotSupportedException
	{
		//这一步返回的这个student还只是一个浅克隆，
		Student student = (Student)super.clone();
		//然后克隆的过程中获得这个克隆的student，然后调用这个getTeacher这个方方法得到这个Teacher对象。然后实现克隆。在设置到这个student中的Teacher。
		//这样实现了双层克隆使得那个teacher对象也得到了复制。
		student.setTeacher((Teacher)student.getTeacher().clone());
		//双层克隆使得那个teacher对象也得到了复制
		return student;
	}
}
class Teacher
{
	private int age;
	private 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
	{
		return super.clone();
	}
	
}

深克隆： Student 和 Teacher 类均实现Cloneable接口

public class CloneTest
{
	public static void main(String[] args) throws Exception
	{
	Teacher teacher = new Teacher();
	teacher.setAge(40);
	teacher.setName("teacher zhang");
	
	Student student = new Student();
	student.setAge(14);
	student.setName("lisi");
	student.setTeacher(teacher);
		
	Student student2 = (Student)student.clone();
	//这里是深复制，所以这时候Student中的teacher就是teacher这个对象的一个复制，就和student2是student的一个复制
	//所以下面teacher.setName只是对他原来的这个对象更改，但是复制的那个并没有更改
	System.out.println(student2.getAge());
	System.out.println(student2.getName());
	System.out.println(student2.getTeacher().getAge());
	teacher.setName("teacher niesong");//不会又任何影响
	System.out.println(student2.getTeacher().getName());
	
	}
 
}
class Student implements Cloneable
{
	private int age;
	private String name;
	private Teacher teacher;
	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 Teacher getTeacher()
	{
		return teacher;
	}
	public void setTeacher(Teacher teacher)
	{
		this.teacher = teacher;
	}
	@Override
	public Object clone() throws CloneNotSupportedException
	{
		//这一步返回的这个student还只是一个浅克隆，
		Student student = (Student)super.clone();
		//然后克隆的过程中获得这个克隆的student，然后调用这个getTeacher这个方方法得到这个Teacher对象。然后实现克隆。在设置到这个student中的Teacher。
		//这样实现了双层克隆使得那个teacher对象也得到了复制。
		student.setTeacher((Teacher)student.getTeacher().clone());
		//双层克隆使得那个teacher对象也得到了复制
		return student;
	}
}
class Teacher implements Cloneable
{
	private int age;
	private 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
	{
		return super.clone();
	}
	
}