关于对象克隆的问题!!!高分!!!!

Question

到底object.clone()是如何实现!!
都说object.clone()是"按位复制",但是object.clone()是如何知道关于子类的信息的呢?
如果是用"class.forName()"的话也是需要一个string的类名参数的呀.
各位高人请赐教object.clone()是如何实现的??
up有分!!
谢谢大家

Answer 1

子类需要重构clone()方法。
另外，对于API提供的通用数据结构如Vector等，需要对其中的每个对象进行克隆。

Answer 2

对于任何java class, 被加载后都在JVM中维护一个class对象，同时会把class中的变量，方法等信息保存在一个称为常量池(constant_pool)的地方，当object.clone实现的时候，JVM就是根据这个信息知道对象中有哪些类型的变量，对于基本类型是可以直接拷贝的，但对于对象类型，直接拷贝是不行的，要进行深拷贝才行。

Answer 3

是一个Class对象还是一个class对象?学习

Answer 4

Object类定义了protected clone()方法，它的作用和c++中按位复制是一样的，因此同样会带来如果对象中包含另一个对象（注意是对象不是基本数据类型，基本数据类型直接就会被复制）的指针（java中的句柄），clone并没有将被包含的对象clone，而是复制了被包含对象的句柄或者说指针。因此并不能认为复制出来的对象就可以随心所欲的修改，因为它和被clone的对象都包含同一个对象，因此可能会引起潜在的冲突问题。至于深度clone的方法很简单，就是在子类中覆盖父类Object类中clone方法，保证每一个被包含的对象都被按照位被clone。如果包含的数据全部是基本类型数据，那么就什么也不用做了。深度clone可以利用Serializable来进行。

Answer 5

to:cathy97(男人练瑜伽好处多)
     如果是这样,也是需要查询常量池的吧?
但是super.clone()的调用只是调用根类的clone(),根类的clone()不知道子类的信息,怎么查询?比如
  class A inplements CLoneable
{
   int i=1;
   char c="r";
   public Object clone()
  {
    return super.clone()
  }
}class B implements Cloneable
{
  int j=2;
  char k="t";
public Object clone()
 {
   return super.clone();
 }
}
两个类同样调用super.clone()
根类是如何区分的呢??

Answer 6

to:kingdoom
所答非所问呀,老大!!!

Answer 7

难道没有看懂？
object.clone() 复制了被包含对象的句柄或者说指针。
如果你要深层复制的话 就要自己在子类 覆写clone()

Answer 8

上面说的有问题，Object.clone()会检查原先的对象有多大，再为新对象腾出足够多的内存，将所有二进制位从原来的对象复制到新对象。根类中的clone()方法负责建立正确的存储容量，并通过“按位复制”将二进制位从原始对象中复制到新对象的存储空间。也就是说，它并不只是预留存储空间以及复制一个对象——实际需要调查出欲复制之对象的准确大小，然后复制那个对象。由于所有这些工作都是在由根类定义之clone()方法的内部代码中进行的（根类并不知道要从自己这里继承出去什么），所以大家或许已经猜到，这个过程需要用RTTI判断欲克隆的对象的实际大小。采取这种方式，clone()方法便可建立起正确数量的存储空间，并对那个类型进行正确的按位复制。
不过象Vector的clone()方法就不能自动尝试克隆Vector内包含的每个对象，所以象Vector这样的集合对象只能进行不能进行深层复制，这些都需要自己覆写。

Answer 9

Object.clone()能够计算出对象的大小,为新对象创建足够的内存空间,并把旧对象的所有比特位复制到新对象.并且负责创建正确容量的存储空间,并进行"逐位复制",由原对象复制到新对象的存储空间中.也就是说它并不是仅仅创建存储空间,然后复制一个Object.它实际是计算出即将复制的真实对象的大小,由于这都发生在根类定义的clone()方法中,可以猜到.是RTTI机制确定要被克隆的实际对象.还有序列化需要的时间差不多是克隆的时间4倍!有些人认为不值得使用java的克隆机制,他们自己实现克隆方法,而且永不调用Object.clone方法. 给你个例子,注意一下里面的BackOn类.//: appendixa:CheckCloneable.java
// Checking to see if a reference can be cloned.
// From 'Thinking in Java, 3rd ed.' (c) Bruce Eckel 2002
// www.BruceEckel.com. See copyright notice in CopyRight.txt.// Can't clone this because it doesn't override clone():
class Ordinary {}// Overrides clone, but doesn't implement Cloneable:
class WrongClone extends Ordinary {
  public Object clone() throws CloneNotSupportedException {
    return super.clone(); // Throws exception
  }
}// Does all the right things for cloning:
class IsCloneable extends Ordinary implements Cloneable {
  public Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}// Turn off cloning by throwing the exception:
class NoMore extends IsCloneable {
  public Object clone() throws CloneNotSupportedException {
    throw new CloneNotSupportedException();
  }
}class TryMore extends NoMore {
  public Object clone() throws CloneNotSupportedException {
    // Calls NoMore.clone(), throws exception:
    return super.clone();
  }
}class BackOn extends NoMore {
  private BackOn duplicate(BackOn b) {
    // Somehow make a copy of b and return that copy.
    // This is a dummy copy, just to make the point:
    return new BackOn();
  }
  public Object clone() {
    // Doesn't call NoMore.clone():
    return duplicate(this);
  }
}// You can't inherit from this, so you can't override
// the clone method as you can in BackOn:
final class ReallyNoMore extends NoMore {}public class CheckCloneable {
  public static Ordinary tryToClone(Ordinary ord) {
    String id = ord.getClass().getName();
    System.out.println("Attempting " + id);
    Ordinary x = null;
    if(ord instanceof Cloneable) {
      try {
        x = (Ordinary)((IsCloneable)ord).clone();
        System.out.println("Cloned " + id);
      } catch(CloneNotSupportedException e) {
        System.err.println("Could not clone " + id);
      }
    } else {
      System.out.println("Doesn't implement Cloneable");
    }
    return x;
  }
  public static void main(String[] args) {
    // Upcasting:
    Ordinary[] ord = {
      new IsCloneable(),
      new WrongClone(),
      new NoMore(),
      new TryMore(),
      new BackOn(),
      new ReallyNoMore(),
    };
    Ordinary x = new Ordinary();
    // This won't compile; clone() is protected in Object:
    //! x = (Ordinary)x.clone();
    // Checks first to see if a class implements Cloneable:
    for(int i = 0; i < ord.length; i++)
      tryToClone(ord[i]);
  }
}

Answer 10

是复制一个对象的引用和实例，jvm从堆里重新拷贝一份和原来一样的，但不依赖原来对象实例

Answer 11

如果在java里加入指针的概念就一目了然了，object.clone()，可以把object理解为一个指针，指向一块存储空间，clone()是把这个空间里的东西都copy一份，放到另一个地方去，于是引出了影子克隆和**（忘了另一个叫什么了，大概是深层克隆吧）由于object是个指针，加入object.clone()这个object有个属性是object_sun, object.clone()的调用只是把object_sun 另存了，而不是把这个 object_sun 的内容另存了，所以object通过object.clone()  克隆出来的对象的 object_sun 属性和object的object_sun 属性指到同一个位置，改变一个，另一个也会变，public class CloneTest 
{    public static void main(String[] args) 
    {
Employee emp = new Employee("kevin");
emp.address = new Address("Beijing");
System.out.println("name: " + emp.name + " age: " + emp.age + " Address: " + emp.address.city);

Employee empClone = (Employee) emp.clone();
empClone.age = 50;
empClone.name = "ding";
empClone.address.city = "Shanghai";
System.out.println("name: " + empClone.name + 
    " age: " + empClone.age
    +" Address: " + emp.address.city);

System.out.println("name: " + emp.name + " age: " + emp.age + " Address: " + emp.address.city);
}
}class Employee implements Cloneable
{
    String name;
    int    age;
    Address address;
    
    public Employee(String name)
    {
this.name = name;
this.age = 30;
    }
    
    public Object clone()
    {
try
{
     return  super.clone();
}
catch(Exception e)
{
     e.printStackTrace();
     }
return null;
    }
}class Address
{
    String city;
    public Address(String city)
    {
this.city = city; 
    }
}
这段代码很好的说明了克隆的机制