j详细说明ava于clone办法

转载

mb5fe18fed96438 2015-09-15 18:42:00

文章标签 java ide 浅拷贝深拷贝拷贝构造函数 文章分类 Java 后端开发

In java, it essentially means the ability to create an object with similar state as the original object.

什么是clone

字典中的意思就是复制（强调跟原来的一模一样）。

*By default, java cloning is ‘field by field copy’ *.由于Object类不知道详细类的结构，无法确定哪个clone方法将被调用。

所以JVM规定clone，做例如以下操作。

假设这个类仅仅有原始数据类型成员的话。那么须要创建一个一模一样的对象，而且返回这个新对象的引用。
假设这个类包括了不论什么类类型成员的话，那么仅仅有这些成员的对象引用被复制。且原始对象和克隆对象的成员的引用将指向同一个对象。

翻译的不好。%>_<%

If the class has only primitive data type members then a completely new copy of the object will be created and the reference to the new object copy will be returned.
If the class contains members of any class type then only the object references to those members are copied and hence the member references in both the original object as well as the cloned object refer to the same object.

除了上面两条默认的操作之外。你也能够重载clone方法，制定一套自己的clone方法。

java中clone规则

每种支持clone的语言都有它自己的规则，java也不例外。java中假设一个类需要支持clone的话。必需要做例如以下事情：

你必须继承Cloneable接口---Cloneable interface is broken in java。otherwise throws java.lang.CloneNotSupportedException.
必须重写Object类中的clone()方法

/*
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  [More ...] clone() throws CloneNotSupportedException;

第一条表明，clone对象分配有独立的内存地址。
第二条表明，原始的和克隆的对象应该具有同样类型，但这不是必须的
第三条表明。原始的和克隆的对象调用equals方法的话，应该时相等的。但这不是必须的。

以下我们通过样例来分析：

class Father implements Cloneable{
    private int age ;
    private String name ;
    private Son son ;

    public Father(int age,String name,Son son){
        this.age = age ;
        this.name = name ;
        this.son = son ;
    }

    public Son getSon(){
        return this.son ;
    }

    @Override
    protected Object clone()throws CloneNotSupportedException{
        return super.clone() ;
    }
}
class Son{
    private int age ;
    private String name ;

    public Son(int age ,String name){
        this.age = age ;
        this.name = name ;
    }

    public void setName(String name){
        this.name = name ;
    }
    public String getName(){
        return this.name ;
    }
}
public class CloneDemo {
    public static void main(String args[]) throws CloneNotSupportedException{
        Son s = new Son(10,"Jack") ;
        Father fa = new Father(40,"Tom",s) ;
        Father clonedFa = (Father) fa.clone() ;

        System.out.println(fa!=clonedFa);
        System.out.println(clonedFa.getClass()==fa.getClass());
        System.out.println(clonedFa.equals(fa));

        //now we change the fa's son name by the clonedFa's son name
        clonedFa.getSon().setName("Jay");
        System.out.println(fa.getSon().getName());
    }
}
/*print:
true
true
false
Jay
*/

上面的代码中能够看出。原始的和克隆的Father类对象。拥有指向同一对象的两个引用。所以能够通过改变clonedFa中的Son来改变fa中Son对象。这就时所谓的浅拷贝.以下我们具体讨论一下浅拷贝和深拷贝。

浅拷贝(Shallow Cloning)

这是java中默认的实现。上面的样例中就是浅拷贝。不创建一个新的克隆拷贝对象Son，而是直接两个引用指向同一对象。

深拷贝

If we want a clone which is independent of original and making changes in clone should not affect original.you can try Deep Cloning.

we change the clone() method in the Father class .

@Override
protected Object clone() throws CloneNotSupportedException {
        Father fa = (Father)super.clone();          
        fa.setSon((Son)fa.getSon().clone());
        return fa;
}

and we need Override the clone() method in the Son class. like this.

@Override
protected Object clone() throws CloneNotSupportedException {
        return super.clone();
}

如今我们已经实现深拷贝了。

拷贝构造函数

拷贝构造函数时一种特殊的构造器。它讲自己的类类型作为參数。我们传递一个类的实例给拷贝构造函数。然后它将返回一个新的类实例。lets see this in example

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;
    }
}

以下是測试代码：

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 {
    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);
    }
}

Cloning with serialization

这是例外一种深拷贝的方法。这里就不多讲了，具体见：A mini guide for implementing serializable interface in java

best practices

1) When you don’t know whether you can call the clone() method of a particular class as you are not sure if it is implemented in that class, you can check with checking if the class is instance of “Cloneable” interface as below.

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

2) No constructor is called on the object being cloned. As a result, it is your responsibility, to make sure all the members have been properly set. Also, if you are keeping track of number of objects in system by counting the invocation of constructors, you got a new additional place to increment the counter.

Reference: