java对象克隆

1. Overiew

在实际编程中，我们经常会遇到这样一个情景：有一个对象A，存在属性方法，现在需要一个和A完全相同的新对象B，并且B的任何改动都不会影响到A中的值。那么，最常用的办法就是对A进行克隆。

2. How to Clone

在java.lang.Object中有一个clone方法，该方法的签名如下：

Java代码

 protected native Object clone() throws CloneNotSupportedException;  

 该方法返回一个Object实例的拷贝，该实例拷贝具有：

1)拷贝对象是一个新对象而不是一个原对象引用。

2)拷贝的对象中包含的是原有对象信息，而不是对象初始化的信息(也就是说，拷贝过程没有调用构造函数)。

从第1条我们可以看出，拷贝的对象与原对象存在这样一种关系：

1. x.clone() != x      will be true
2. x.clone().getClass() == x.getClass() will be true, but these are not absolute requirements
3. x.clone().equals(x) will be true, but these are not absolute requirements

 

要实现克隆，必须满足一下三点：

1)类必须实现Cloneable接口

2)类必须重载Object类中的clone()方法

3)重载的clone()方法中，必须显示调用super.clone()。

我们看一下Cloneable接口的定义:

 public interface Cloneable { }   

Cloneable接口是不包含任何方法的,仅仅表示一个标志(类似Serializable接口)，而且这个标志也是针对Object类中clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法(也就是调用了super.Clone()方法)，那么Object的clone()方法就会抛出CloneNotSupportedException异常。

按照要求，我们写一个克隆类的小例子:

public class DummyClone implements Cloneable{     
    
    public Object clone(){     
        DummyClone dc = null;     
        try {     
            dc = (DummyClone)super.clone();     
        } catch (CloneNotSupportedException e) {     
            e.printStackTrace();     
        }     
        return dc;     
    }     
}   

3. Shadow Clone

首先，我们来看一个例子：ClassA没有实现Cloneable接口。ClassB存在ClassA的实例，实现了Cloneable接口，并重载了clone方法。ClassC实例化一个ClassB对象，然后克隆一个对象。

Java代码

class ClassA {     
         
    public int a;     
         
    public void doubleA(){     
        a = a * 2;     
    }     
         
    public ClassA(int aa){     
        this.a = aa;     
    }     
         
    public String toString(){     
        return Integer.toString(a);     
    }     
}     
    
class ClassB implements Cloneable{     
         
    public int b;     
         
    public ClassA ca = new ClassA(11);     
         
    public Object clone(){     
        ClassB cb = null;     
        try {     
            cb = (ClassB)super.clone();     
        } catch (CloneNotSupportedException e) {     
            e.printStackTrace();     
        }     
        return cb;     
    }     
}     
    
public class ClassC {     
         
    public static void main(String[] args) {     
        ClassB cb = new ClassB();     
        cb.b = 222;     
        System.out.println("before clone : cb.b = " + cb.b);     
        System.out.println("before clone : cb.ca = " + cb.ca);     
             
        //     
        ClassB cb2 = (ClassB)cb.clone();     
        cb2.b = 3333;     
        cb2.ca.doubleA();     
        System.out.println("========================");     
        System.out.println("after clone : cb.b = " + cb.b);     
        System.out.println("after clone : cb.ca = " + cb.ca);     
        System.out.println("========================");     
        System.out.println("after clone : cb2.b = " + cb2.b);     
        System.out.println("after clone : cb2.ca = " + cb2.ca);     
    }     
}    

输出结果如下：

Java代码

before clone : cb.b = 222
before clone : cb.ca = 11
========================
after clone : cb.b = 222
after clone : cb.ca = 22
========================
after clone : cb2.b = 3333
after clone : cb2.ca = 22

从结果我们看到，int类型的b被完全的克隆了，而ClassA类型的ca却没有被克隆。因为克隆后cb2对b的赋值不会影响原有cb中b的值，而调用cb2.ca.doubleA()方法后，对cb2.ca的改变同时改变了cb.ca，表明cb2.ca与cb.ca仅仅指向同一个对象的不同引用。从中可以看出，调用Object类中clone()方法产生的效果是：先在内存中开辟一块和原始对象一样的空间，然后原样拷贝原始对象中的内容。对基本数据类型，这样的操作是没有问题的，但对非基本类型变量clone后的变量和原始对象中相应的变量指向的是同一个对象。

这就是影子克隆。影子克隆，并没有完整的完成克隆，有时候这并不是我们想要的结果。我们有时需要，就像列子中调用cb2.ca.doubleA()方法时，不会对原对象产生改变，这时候我们就需要deep clone;

4. Deep Clone

要实现深度克隆,在上面的例子基础上，我们只需要这样修改即可：

class ClassA implements Cloneable{     
         
    public int a;     
         
    public void doubleA(){     
        a = a * 2;     
    }     
         
    public ClassA(int aa){     
        this.a = aa;     
    }     
         
    public String toString(){     
        return Integer.toString(a);     
    }     
         
    public Object clone(){     
        ClassA ca = null;     
        try {     
            ca = (ClassA)super.clone();     
        } catch (CloneNotSupportedException e) {     
            e.printStackTrace();     
        }     
        return ca;     
    }     
}     
    
class ClassB implements Cloneable{     
         
    public int b;     
         
    public ClassA ca = new ClassA(11);     
         
    public Object clone(){     
        ClassB cb = null;     
        try {     
            cb = (ClassB)super.clone();     
        } catch (CloneNotSupportedException e) {     
            e.printStackTrace();     
        }     
        cb.ca = (ClassA)ca.clone();     
        return cb;     
    }     
}     
    
public class ClassC {     
         
    public static void main(String[] args) {     
        ClassB cb = new ClassB();     
        cb.b = 222;     
        System.out.println("before clone : cb.b = " + cb.b);     
        System.out.println("before clone : cb.ca = " + cb.ca);     
             
        //     
        ClassB cb2 = (ClassB)cb.clone();     
        cb2.b = 3333;     
        cb2.ca.doubleA();     
        System.out.println("========================");     
        System.out.println("after clone : cb.b = " + cb.b);     
        System.out.println("after clone : cb.ca = " + cb.ca);     
        System.out.println("========================");     
        System.out.println("after clone : cb2.b = " + cb2.b);     
        System.out.println("after clone : cb2.ca = " + cb2.ca);     
    }     
}    

输出结果：

before clone : cb.b = 222    
before clone : cb.ca = 11    
========================     
after clone : cb.b = 222    
after clone : cb.ca = 11    
========================     
after clone : cb2.b = 3333    
after clone : cb2.ca = 22 

基本的数据类型可以自动的实现深度的克隆，然而并不是所有的类都可以进行深度的克隆，就比如String类，其类定义为final，且没有重载clone方法，我们就无法完成对String类的深度克隆。关于不可变对象的克隆，我们通常没有必要去克隆。

自己写的克隆：

package clone;

public class Employee3 implements Cloneable{
    private String name;
    private int salary;
    
    public Employee3()
    {
    
    }
    
    public Employee3(String name,int salary)
    {
       this.name=name;
       this.salary=salary;
    }
    
    public String getName()
    {
        return name;
    }

    public int getSalary()
    {
        return salary;
    }
    
    public Object  clone() throws CloneNotSupportedException
    {
         Employee3 emp=null;
        try {

         emp= (Employee3)super.clone();
            
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
         return emp;
         
    }
}

是这样的.object的clone（）方法是protected。如果我们在测试类直接调用会报错：The method clone() from the type Object is not visible

因为他对Object.clone()进行了多态性的调用，而这个方法被声明是受保护的。

我们需要在Employee3类中添加clone（）方法的一个只访问覆盖版本。只访问覆盖版本没有添加逻辑，他只是放松了对你的代码的访问限制public。记住覆盖的方法的访问限制不能比基类方法更严格，但是可以更宽松。

public class Cloner {
    
    public static void main(String[] args) throws CloneNotSupportedException
    {
        Employee3 e=new Employee3("Dolly",1000);
        
        System.out.println(e);
        
        System.out.println("the employee's name is "+e.getName());
        System.out.println("the employee's salary is "+e.getSalary());
        
        /*Type mismatch: cannot convert from Object to Employee3
         * *
         *低---》高 强制转换
         */
        Employee3 eClone=(Employee3)e.clone(); 
        
       System.out.println(eClone);
        
        System.out.println("the employee's name is "+eClone.getName());
        System.out.println("the employee's salary is "+eClone.getSalary());
            
    }

}

输出：

clone.Employee3@c17164
the employee's name is Dolly
the employee's salary is 1000
clone.Employee3@1fb8ee3 与前面的不同，说明不是同一个对象
the employee's name is Dolly
the employee's salary is 1000

via:http://developer.51cto.com/art/201105/260821.htm

http://liuwang126.iteye.com/blog/272595