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

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

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

protected native Object clone() throws CloneNotSupportedException;

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

然后结果是调用不了

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

不实现Cloneable接口，只是报CloneNotSupportedException异常。

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

疑惑这是为什么呢？

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());

}

}

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，重写clone()方法。

刚看我也很疑惑，试了一下，发现是直接调用object中的clone方法的。

代码如下：

public class CommonTest implements Cloneable{

public static String name  = "hell0";

public static void main(String[] args){

try{

CommonTest aa = new CommonTest();

CommonTest ee = (CommonTest) aa.clone();

System.out.println("Clone succeed");

System.out.println(ee.name);

}catch (CloneNotSupportedException e) {

System.out.print("clone failed");

}

}

}