- 实现Cloneable接口，标识这个对象是可拷贝的。在JVM中带有这个标记的对象才有可能被拷贝。覆写clone方法，变为可能。
对象clone时，不会执行构造函数。那么为什么呢，Obejct类的clone方法原理是从内存中以二进制流的形式拷贝对象，然后重新分配一份内存块。
直接上代码看效果，准备一个公共测试对象
public class Thing implements Cloneable{
private List<String> list = new ArrayList<>();
public Thing() {
System.out.println("执行构造函数...");
}
@Override
protected Thing clone() throws CloneNotSupportedException {
Thing thing = null;
thing = (Thing) super.clone();
return thing;
}
public void setValue(String value){
this.list.add(value);
}
public List<String> getValue(){
return this.list;
}
}
浅拷贝：
public static void main(String[] args) throws CloneNotSupportedException {
//先new一个对象/原生对象
Thing thing = new Thing();
//并且在这个对象的私有变量里面添加一个值
thing.setValue("zhangsan.");
//产生一个copy对象，
Thing cloneThing = thing.clone();
//在copy对象的私有list里面也增加一个值
cloneThing.setValue("lisi.");
//thing.setValue("wangmazi.");
//打印结果
System.out.println(thing.getValue());
}
执行结果：
执行构造函数...
[zhangsan., lisi.]
为了更明显，我们在代码最后往原生对象list变量里面再add一个值。
public static void main(String[] args) throws CloneNotSupportedException {
//先new一个对象
Thing thing = new Thing();
//并且在这个对象的私有变量里面添加一个值
thing.setValue("zhangsan.");
//产生一个copy对象，
Thing cloneThing = thing.clone();
//在copy对象的私有list里面也增加一个值
cloneThing.setValue("lisi.");
thing.setValue("wangmazi.");
//打印结果
System.out.println(thing.getValue());
}
看结果：
执行构造函数...
[zhangsan., lisi., wangmazi.]
怎么会这样，copy对象私有变量的改变，原生对象也改变了。或者说这两个对象共同拥有了同一个变量，那也可以说明变量的引用地址是同一个。并没有重新分配内存，确实非常浅。
Java做了一个偷懒的copy动作，Object类提供的clone方法，只copy本对象，其对象内部的数组，引用对象等都不拷贝，还是指向原生对象的元素地址，但是对基本数据类型int ,long,char等都会copy。
简单来说，在浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。
ps : 声明一个值类型变量，编译器会在栈上分配一个空间，这个空间对应着该值类型变量，空间里存储的就是该变量的值。引用类型的实例分配在堆上，新建一个引用类型实例，得到的变量值对应的是该实例的内存分配地址，这就像您的银行账号一样。
深拷贝：
反证法，两个对象互不影响，你修改你的，我修改我的，就是深拷贝。
public class Thing implements Cloneable{
private ArrayList<String> list = new ArrayList<>();
public Thing() {
System.out.println("执行构造函数...");
}
@Override
protected Thing clone() throws CloneNotSupportedException {
Thing thing = null;
thing = (Thing) super.clone();
//对类私有的变量，进行单独的copy
thing.list = (ArrayList<String>) this.list.clone();
return thing;
}
public void setValue(String value){
this.list.add(value);
}
public List<String> getValue(){
return this.list;
}
public static void main(String[] args) throws CloneNotSupportedException {
//先new一个对象
Thing thing = new Thing();
//并且在这个对象的私有变量里面添加一个值
thing.setValue("zhangsan.");
//产生一个copy对象，
Thing cloneThing = thing.clone();
//在copy对象的私有list里面也增加一个值
cloneThing.setValue("lisi.");
thing.setValue("wangmazi.");
//打印原生对象变量
System.out.println(thing.getValue());
}
看结果：
执行构造函数...
[zhangsan., wangmazi.]
如果对象变量中有引用类型，建议使用深拷贝。
JVM中：根据对象或者数据的大小，从堆中开辟一块同等大小的内存，然后把原始对象的数据都复制到新的内存地址，对于基本类型，可以把原始值复制过来，但是对于内部对象来说，其保存的只是一个地址，复制时也是对地址的复制，最终还是指向同一个对象，
详见JVM代码
JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
JVMWrapper("JVM_Clone");
Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
const KlassHandle klass (THREAD, obj->klass());
JvmtiVMObjectAllocEventCollector oam;
#ifdef ASSERT
// 检查克隆标志
if (obj->is_javaArray()) {
guarantee(klass->is_cloneable(), "all arrays are cloneable");
} else {
guarantee(obj->is_instance(), "should be instanceOop");
bool cloneable = klass->is_subtype_of(SystemDictionary::Cloneable_klass());
guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
}
#endif
// 检查Class 是否实现了cloneable接口
//数组可以直接Clone
// All arrays are considered to be cloneable (See JLS 20.1.5)
if (!klass->is_cloneable()) {
ResourceMark rm(THREAD);
THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
}
// 浅拷贝
const int size = obj->size();
oop new_obj = NULL;
if (obj->is_javaArray()) {
const int length = ((arrayOop)obj())->length();
new_obj = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL);
} else {
new_obj = CollectedHeap::obj_allocate(klass, size, CHECK_NULL);
}
