java中对象的克隆

克隆是完全复制另一个物体，在java中，意味着创建一个和原对象有相似状态的对象。clone()方法就提供了这个功能，在这篇文章中，我们将探索java 克隆的一些最重要的方面。这篇文章是mini guides的一个部分

详细解释克隆

克隆是创建原对象的一个复制，字典上的意思是“精确的复制”。默认情况下，java的克隆是一个字段一个字段的复制。例如：对象类调用的clone()方法，对将要复制的类的结构并没有一个清晰的了解。那么当克隆的时候，JVM将会做以下的事情：

1、如果这个类只有原生数据类型成员，那么一个原对象的完全复制会被创建，新对象的引用将会被返回。

2、如果这个对象包含类类型，那么只有这些对象的引用会被复制，因此克隆对象和原对象的成员的引用指向同一个对象。

除了默认的情况，你可以重写这些行为并指定自己的方式，这需要覆盖clone()方法，让我们看看是怎么样克隆的？

java克隆的构造

支持克隆对象的每一种语言都有自己的克隆规则，java也是。在java中，如果一个类需要支持克隆，那么它需要做两件事情。

1、你必须实现Cloneable接口。

2、你必须在类中重写clone()方法

在java文档中给出了下边的解释：

/*
Creates and returns a copy of this object. The precise meaning of "copy" may depend on the class of the object.
The general intent is that, for any object x, the expression:
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, this is not an absolute requirement.
*/
protected native Object  clone() throws CloneNotSupportedException;

1、第一个语句保证了克隆对象会有独立的内存地址分配

2、第二个语句表明原生对象和克隆对象的需要具有相同的类型，但是不是强制的

3、第三个语句表明原生对象和克隆对象使用equals()时应该是相等的，但是也是不是强制的。

让我们看看实际的代码：

我们的第一个类Employee有三个属性 Id，name和department

public class Employee implements Cloneable{
 
    private int empoyeeId;
    private String employeeName;
    private Department department;
 
    public Employee(int id, String name, Department dept)
    {
        this.empoyeeId = id;
        this.employeeName = name;
        this.department = dept;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
     
    //Accessor/mutators methods will go there
}

我们的Department类有两个属性，id和name

public class Department
{
    private int id;
    private String name;
 
    public Department(int id, String name)
    {
        this.id = id;
        this.name = name;
    }
    //Accessor/mutators methods will go there
}

所以如果我们想克隆Employee类，那么我们需要做像下边的事情：

public class TestCloning {
 
    public static void main(String[] args) throws CloneNotSupportedException
    {
        Department dept = new Department(1, "Human Resource");
        Employee original = new Employee(1, "Admin", dept);
        //Lets create a clone of original object
        Employee cloned = (Employee) original.clone();
        //Let verify using employee id, if cloning actually workded
        System.out.println(cloned.getEmpoyeeId());
 
        //Verify JDK's rules
 
        //Must be true and objects must have different memory addresses
        System.out.println(original != cloned);
 
        //As we are returning same class; so it should be true
        System.out.println(original.getClass() == cloned.getClass());
 
        //Default equals method checks for refernces so it should be false. If we want to make it true,
        //we need to override equals method in Employee class.
        System.out.println(original.equals(cloned));
    }
}
Output:
1
true
true
false

我们已经成功克隆了Employee对象，但是，记住我们已经有同一个对象的两个引用了，现在这连个都会改变在不同的应用中改变状态。

public class TestCloning {
 
    public static void main(String[] args) throws CloneNotSupportedException {
        Department hr = new Department(1, "Human Resource");
        Employee original = new Employee(1, "Admin", hr);
        Employee cloned = (Employee) original.clone();
 
        //Let change the department name in cloned object and we will verify in original object
        cloned.getDepartment().setName("Finance");
 
        System.out.println(original.getDepartment().getName());
    }
}
Output: Finance

克隆对象和原生对象的值都改变了，如果允许这么做可能会引起系统的损毁，任何人都可以克隆你的对象，并改变你对象的引用，这将会是灾难性的，那么怎么阻止它呢？

我们可以使用深度克隆和复制构造来解决这个问题，我们会在这篇文章的后边学习

浅克隆

这是java中默认的实现的方式，复写clone方法时，如果你没有克隆所有的对象类型（不是原生类型），那么你就是浅克隆。所有的上边的例子都是浅克隆，因为我们没有在Employee类的clone方法中克隆Department对象，现在我们来介绍深克隆。

深克隆

在大多数情况下，这是最想要的行为：我们克隆的对象的行为的改变不会影响到原生对象的值。

我们来看一下在我们的例子中如何来做：

//Modified clone() method in Employee class
@Override
protected Object clone() throws CloneNotSupportedException {
    Employee cloned = (Employee)super.clone();
    cloned.setDepartment((Department)cloned.getDepartment().clone());
    return cloned;
}

我修改了Employee中的clone方法并在Department类中的clone方法中增加了如下代码：

//Defined clone method in Department class.
@Override
protected Object clone() throws CloneNotSupportedException {
    return super.clone();
}

现在我们来测试一下：

public class TestCloning {
    public static void main(String[] args) throws CloneNotSupportedException {
        Department hr = new Department(1, "Human Resource");
        Employee original = new Employee(1, "Admin", hr);
        Employee cloned = (Employee) original.clone();
 
        //Let change the department name in cloned object and we will verify in original object
        cloned.getDepartment().setName("Finance");
 
        System.out.println(original.getDepartment().getName());
    }
}
Output:
Human Resource

这里克隆对象的改变并没有改变原生对象的值

那么深克隆需要满足下边的情况：

1、没有必要单独复制primitive

2、原生对象中的所有类成员都必须支持clone方法，在原生对象的成员类中都要调用super.clone()方法

3、如果类成员变量不支持clone，那么它必须创建那个成员类的新的实例，并把它的属性一个一个的复制到新的对象中去，新的类成员对象在clone对象中被设置。

使用复制构造

复制构造是类中特殊的构造方法，它需要把自己的类型当做参数，所以当你传递一个类的实例给复构造时，这个构造会返回参数给出的类型的实例，我们来看下边这个例子：

public class PointOne {
    private Integer x;
    private Integer y;
 
    public PointOne(PointOne point){
        this.x = point.x;
        this.y = point.y;
    }
}

这个方法看起来很简单，但是当继承的时候就不是这样了。当你定义一个类继承上边这个类，你需要定义相似的构造方法，在子类中，你需要复制子类的属性并且传递给父类的构造传递参数

public class PointTwo extends PointOne{
    private Integer z;
 
    public PointTwo(PointTwo point){
        super(point); //Call Super class constructor here
        this.z = point.z;
    }
}

这样就可以了吗？不行，问题是继承是运行时的行为，所以在我们的例子中，如果一些类传递PointTwo的实例在PointOne的构造中，你将会得到PointOne的实例。我们来看下边的代码：

class Test
{
    public static void main(String[] args)
    {
        PointOne one = new PointOne(1,2);
        PointTwo two = new PointTwo(1,2,3);
 
        PointOne clone1 = new PointOne(one);
        PointOne clone2 = new PointOne(two);
 
        //Let check for class types
        System.out.println(clone1.getClass());
        System.out.println(clone2.getClass());
    }
}
Output:
class corejava.cloning.PointOne
class corejava.cloning.PointOne

创建复制构造的另一种方式是利用静态工厂方法，他们把类的类型作为参数，使用类的其他构造方法创建实例。那么这些工厂方法将会复制所有的状态数据到新的类实例中去。

public class PointOne implements Cloneable{
    private Integer x;
    private Integer y;
 
    public PointOne(Integer x, Integer y)
    {
        this.x = x;
        this.y = y;
    }
 
    public PointOne copyPoint(PointOne point) throws CloneNotSupportedException
    {
        if(!(point instanceof Cloneable))
        {
            throw new CloneNotSupportedException("Invalid cloning");
        }
        //Can do multiple other things here
        return new PointOne(point.x, point.y);
    }
}

序列化的克隆

这是深克隆的另一种简单的方式，这种方法，你只需要序列化需要克隆的对象并反序列化就可以了。显然需要克隆的对象应该实现序列化接口。在进行下一步之前，我需要提醒的是它不能被轻易的使用，首先序列化有高昂的代价，它可能是clone方法的上百倍，第二并非所有的对象都是可以序列化的，第三类序列化并不是一个可以依赖的，它并不可靠。

@SuppressWarnings("unchecked")
public static  T clone(T t) throws Exception {
    //Check if T is instance of Serializeble other throw CloneNotSupportedException
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
 
    //Serialize it
    serializeToOutputStream(t, bos);
    byte[] bytes = bos.toByteArray();
    ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
 
    //Deserialize it and return the new instance
    return (T)ois.readObject();
}

使用apche Commons克隆

apche commons也实现了深克隆的功能，如果你感兴趣可以查看文档说明，下边这是使用的一个简单的例子

SomeObject cloned = org.apache.commons.lang.SerializationUtils.clone(someObject);

最佳实践

1、当你不知道你是否可以调用clone方法的时候，你可以使用 class is instance of Cloneable来检查：

if(obj1 instanceof Cloneable){
    obj2 = obj1.clone();
}
 
//Dont do this. Cloneabe dont have any methods
obj2 = (Cloneable)obj1.clone();

2、被克隆的对象中没有构造方法被调用，你应该负责所有的成员变量被恰当的设置，如果你在构造方法中跟踪对象的调用，那么这也是一个增加计数器的地方

原文地址：http://howtodoinjava.com/2012/11/08/a-guide-to-object-cloning-in-java/