Java类中为什么不能直接调用Object的clone()方法

在Java中所有的类都是Object的子类。

在Object类中有一个clone方法定义如下：

protected native Object clone() throws CloneNotSupportedException;

该方法的修饰符为protected，表示该方法可以在子类中调用

---

然后结果是调用不了

网上有回答是需要实现Cloneable接口，但即使实现了，也调用不到。
不实现Cloneable接口，只是报CloneNotSupportedException异常。

只能重写clone方法，并且使用super.clone()

疑惑这是为什么呢？

---

clone() 是protected的作用域。继承Cloneable接口后要重写方法，然后在方法里调用父类的clone()的方法。同时默认的克隆对于引用对象只是浅克隆。给你一段代码自己去运行试试吧：

package cesar.Test0810;

/**
 * Created by Cesar on 2016/8/10.
 */
public class A implements Cloneable{

    private int a;
    private B b;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public B getB() {
        return b;
    }

    @Override
    public String toString() {
        return "A{" +
                "a=" + a +
                ", b=" + b +
                '}';
    }

    public void setB(B b) {
        this.b = b;
    }

    protected A clone() throws CloneNotSupportedException {
        return (A) super.clone();
    }
}

package cesar.Test0810;

/**
 * Created by Cesar on 2016/8/10.
 */
public class B {

    private int b1;
    private int b2;

    @Override
    public String toString() {
        return "B{" +
                "b1=" + b1 +
                ", b2=" + b2 +
                '}';
    }

    public B(int b1, int b2){
        this.b1 = b1;
        this.b2 = b2;
    }

    public int getB1() {
        return b1;
    }

    public void setB1(int b1) {
        this.b1 = b1;
    }

    public int getB2() {
        return b2;
    }

    public void setB2(int b2) {
        this.b2 = b2;
    }
}

package cesar.Test0810;

/**
 * Created by Cesar on 2016/8/10.
 */
public class TestClone {

    public static void main(String[] args) {

        A a = new A();
        B b = new B(1, 2);

        a.setA(10);
        a.setB(b);
        try {
            A a1 = a.clone();
            System.out.println("a=" + a.toString());
            System.out.println("a1=" + a1.toString());

            a.setA(1000);
            a.getB().setB1(10000);
            a.getB().setB2(8000);

            System.out.println("a=" + a.toString());
            System.out.println("a1=" + a1.toString());

            a.setB(new B(9999,9999));

            System.out.println("a=" + a.toString());
            System.out.println("a1=" + a1.toString());


        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

• 其中A继承了cloneable接口，同时持有了对B的引用。

---

Cloneable接口仅仅是个标志，他里面是空的
Object的clone方法是本地方法，比较有效率
使用clone方法的几个条件

1）在派生类中实现Cloneable借口。

　　2）为了获取对象的一份拷贝，我们可以利用Object类的clone方法。

　　3）在派生类中覆盖积累的clone方法，声明为public。

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

再具体的你可以参考
http://www.cnblogs.com/gw811/...

---

可以调用啊：

public class Test implements Cloneable{
    private int foo;

    public Test(int foo) {
        this.foo = foo;
    }

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

    public int getFoo() {
        return foo;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Test test = new Test(1);
        Test cloned = (Test) test.clone();
        System.out.println(cloned.getFoo());
    }
}

---

实现接口Cloneable，重写clone()方法。