这是我参与更文挑战的第4天，活动详情查看： 更文挑战
Java中拷贝的含义
拷贝即clone，在Java语言中，通过调用clone方法来实现复制一个对象。首先应该划分一个和目标对象空间一致的内存空间，在该空间中根据目标对象的数据来创建一个新的对象。
Java中使用new和clone方法创建一个对象的不同：
- 使用new操作符。new操作符用来分配内存，程序执行到new操作符时， 首先去看new操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化，构造方法返回后，一个对象创建完毕，可以把他的引用（地址）发布到外部，在外部就可以通过引用操纵对象。
- 使用clone方法。而clone在第一步是和new相似的， 都是分配内存，调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后再使用原对象中对应的各个域，填充新对象的域， 填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部。
需要注意的是clone方法位于Object内部，且是受保护的类型(protected)，必须重写该类并实现Cloneable方法。
浅拷贝
当我们调用clone方法拷贝一个对象时，若对象的属性为基本类型，则可以直接复制该值，但属性为其他对象时，这时在浅拷贝中复制的是对象的引用地址。这也说明拷贝对象和源对象的对象属性是相等的。例如以下:
public class Response implements Cloneable{
public String name;
public int age;
private ResponseImpl wrapper;
public ResponseImpl getWrapper() {
return wrapper;
}
public void setWrapper(ResponseImpl wrapper) {
this.wrapper = wrapper;
}
@NonNull
@Override
protected Object clone() throws CloneNotSupportedException {
Response response = (Response) super.clone();
return response;
}
}
在这里我们创建了一个Response类，实现了Cloneable接口并重写了clone方法。Response类内部有一个属性为ResponseImpl类，该类并没有实现Cloneable接口。我们看一下运行结果：
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
response1=new Response();
response1.name="yydm";
response1.age=10;
ResponseImpl wrapper=new ResponseImpl();
wrapper.height=172;
response1.setWrapper(wrapper);
try {
response2= (Response) response1.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
public void start(View view) {
Log.i("MDY", "name="+response1.name+" age="+response1.age);
Log.i("MDY", "name-hashcode="+response1.name.hashCode()+" wrapper-hashcode="+response1.getWrapper().hashCode());
Log.i("MDY", "start------------");
Log.i("MDY", "name="+response2.name+" age="+response2.age);
Log.i("MDY", "name-hashcode="+response2.name.hashCode()+" wrapper-hashcode="+response2.getWrapper().hashCode());
}
结果：
2020-01-02 22:47:49.988 20574-20574/com.mdy.rp I/MDY: name=yydm age=10
2020-01-02 22:47:49.989 20574-20574/com.mdy.rp I/MDY: name-hashcode=836268084 wrapper-hashcode=223567989
2020-01-02 22:47:49.989 20574-20574/com.mdy.rp I/MDY: start------------
2020-01-02 22:47:49.989 20574-20574/com.mdy.rp I/MDY: name=yydm age=10
2020-01-02 22:47:49.989 20574-20574/com.mdy.rp I/MDY: name-hashcode=836268084 wrapper-hashcode=223567989
可以看到 wrapper对象的hashcode是相等的，因此clone的对象response2的wrapper属性 clone的是对象引用。
深拷贝
深拷贝和浅拷贝的不同之处在于，源对象中的对象属性在被拷贝时，会根据源对象属性的内存大小划分一块内存空间，并根据源属性的值创建一个新的属性。例如以下：
public class Response implements Cloneable{
public String name;
public int age;
private ResponseImpl wrapper;
public ResponseImpl getWrapper() {
return wrapper;
}
public void setWrapper(ResponseImpl wrapper) {
this.wrapper = wrapper;
}
@NonNull
@Override
protected Object clone() throws CloneNotSupportedException {
Response response = (Response) super.clone();
response.wrapper= (ResponseImpl) wrapper.clone();
return response;
}
}
public class ResponseImpl implements Cloneable{
public long height;
@NonNull
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
可以看到首先在属性对象的类中实现Cloneable接口，并重写clone方法。然后在Response的clone函数中分别实现自身的clone方法和属性对象的clone方法。看一下运行结果：
2020-01-02 22:54:49.543 20784-20784/com.mdy.rp I/MDY: name=yydm age=10
2020-01-02 22:54:49.543 20784-20784/com.mdy.rp I/MDY: name-hashcode=836268084 wrapper-hashcode=223567989
2020-01-02 22:54:49.543 20784-20784/com.mdy.rp I/MDY: start------------
2020-01-02 22:54:49.543 20784-20784/com.mdy.rp I/MDY: name=yydm age=10
2020-01-02 22:54:49.543 20784-20784/com.mdy.rp I/MDY: name-hashcode=836268084 wrapper-hashcode=56748042
可以看到wrapper的hashcode值不相同，表明是两个对象了。
