Java浅克隆深克隆

1．定义

⑴浅复制（浅克隆）

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

⑵深复制（深克隆）

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

2．Java的clone()方法

• clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
  • ①对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象
  • ②对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样
  • ③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。
• Java中对象的克隆Object类的clone()方法，浅克隆
  • ①实现Cloneable接口
  • ②重写clone()方法 
  • ③调用super.clone()。 

说明：
①为什么重写Object的clone()方法时，一定要调用super.clone()呢？

在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。 
②继承自java.lang.Object类的clone()方法是浅复制。以下代码可以证明之。

/**   
* @Title: Student.java  
* @Package stu  
* @Description: TODO(用一句话描述该文件做什么)  
* @author LingLee 
* @date 2017年6月14日 上午9:28:49  
* @version V1.0   
*/   
package stu;

/**   
 * @Title: Student   
 * @Description: TODO(用一句话描述该文件做什么)  
 */
class Professor{
	String name;
	int age;
	public Professor(String name, int age) {
		this.name = name;
		this.age = age;
	}
}
public class Student implements Cloneable {
	private String name;//常量对象，修改克隆对象的该属性，对源对象没有影响。但是如果是非常量引用就不同
	private int age;
	private Professor p;//非常量对象，两个学生同一个professor引用
	public Student(String name,int age,Professor p){
		this.name=name;this.age=age; this.p=p;
	}
	public Student(String name,int age){
		this.name=name;this.age=age; 
	}
	public Object clone(){
		Object o=null;
		try{
			o=super.clone();
		}catch(Exception e){
			e.printStackTrace();
		}
		return o;
	}
	
	public static void main(String[] args){
		
		Student s1=new Student("jk",18);
		Student s2=(Student)s1.clone();
		System.out.println(s1!=s2);//克隆对象与元对象不是一个对象 true
		System.out.println(s1.getClass()==s2.getClass());//两者是同一种类的实例 true
		s2.name="ab";
		s2.age=20;
		//********
		System.out.println("s1.name="+s1.name+"\ts1.age="+s1.age);//修改s2后不影响s1 s1.name=jk	s1.age=18
		System.out.println("s2.name="+s2.name+"\ts2.age="+s2.age);//s2.name=ab	s2.age=20
		
		Professor p=new Professor("cd",45);
		Student s3=new Student("jk",18,p);
		Student s4=(Student)s3.clone();
		s4.p.name="hh";
		s4.p.age=50;
		System.out.println("s3.name="+s3.p.name+"\ts3.age="+s3.p.age);//s3 s4的引用成员指向同一引用。s3.name=hh	s3.age=50
	}
}

自我克隆十分高效，如：clone 100个元素的int [ ] 数组，系统默认的clone 比静态的copy 方法快接近2倍，但只是一种浅克隆

 

深克隆实现：

（1）增加引用的克隆

class Professor implements Cloneable    
{    
     String name; int age;    
     ...  
    public Object clone()    
     {    
         Object o=null;    
        try{    
             o=super.clone();    
         }catch(CloneNotSupportedException e){ }    
        return o;    
     }    
}    
class Student implements Cloneable    
{    
    ...   
    public Object clone()    
     {    
         Student o=null;    
        try{
o=(Student)super.clone();    
         }catch(CloneNotSupportedException e){ }    
         o.p=(Professor)p.clone();    
        return o;    
     }    
}  

（2）利用串行化

把对象写到流里的过程是串行化（Serilization）过程，“冷冻”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做 “解冻”。
深克隆常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到流里，再从流里读出来

Public class Stu implements Serializable{
public Object deepClone() throws Exception   
{    
Object o=null;
//将对象写到流里    
	ByteArrayOutoutStream bo=new ByteArrayOutputStream();    
	ObjectOutputStream oo=new ObjectOutputStream(bo);    
	oo.writeObject(this);    
//从流里读出来    
	ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());    
	ObjectInputStream oi=new ObjectInputStream(bi);
o=oi.readObject();    
	return o;    
} 
} 

 

这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。上例代码改进如下。

 

class Teacher implements Serializable{
String name;
int age;
Teacher(String name,int age){...}
}
class Student implements Serializable{
String name;//常量对象
int age;
Teacher t;//学生1和学生2的引用值都是一样的。
Student(String name,int age,Teacher t){...}

public Object deepClone() throws IOException,
OptionalDataException,ClassNotFoundException{
Object o=null;
//将对象写到流里
	ByteArrayOutoutStream bo=new ByteArrayOutputStream();
	ObjectOutputStream oo=new ObjectOutputStream(bo);
	oo.writeObject(this);
//从流里读出来
	ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
	ObjectInputStream oi=new ObjectInputStream(bi);
O=oi.readObject();
	return o;
}
}
public static void main(String[] args){ 
Teacher t=new Teacher("tangliang",30);
Student s1=new Student("zhangsan",18,t);
Student s2=(Student)s1.deepClone();
s2.t.name="tony";
s2.t.age=40;
System.out.println("name="+s1.t.name+","+"age="+s1.t.age);//学生1的老师不改变
}