最近在看java集合的相关源码，在看集合的相关源码的时候发现了clone方法，下面是自己对clone方法的一些理解。
一.概括
我们手上有一个对象的时候，我们还想要一个一样的对象，最先想到的方法是new一个出来，再往里面设置一模一样的值，这样做完全可以，但有更简单的方法，那就是用clone方法，不过在用clone方法的时候我们有几点需要注意的地方:
1. clone是Object类的一个由protected和native修饰的方法，由native修饰，说明clone方法是由c++实现的，protected修饰，说明不是同一个包下或不是子孙类无法调用此方法。如果我们要想调用clone方法，一般要重写clone方法。在重写的方法中，一般这样写Object objiect = super.clone();
2.在重写了clone方法后不是就可以调用clone方法了，还需要这个类实现Cloneable接口，Cloneable接口里面什么方法都没有，是一个标记接口。
3.如果在clone方法里面只是写Object objiect = super.clone();那么这个clone方法是对当前对象的一种浅拷贝。
二.浅拷贝和深拷贝
1.浅拷贝
对一个对象进行浅拷贝，会生成一个新的对象的同时也就将原对象的属性拷贝一份，注意这是一个新的对象，所以他们的内存地址是不一样的。如果原对象的属性是基本类型或String类型的，那么拷贝的时候也会生成一份新的， 无论是对原对象还是拷贝对象的基本属性做出改变，都不会影响到彼此。如果原对象的属性是引用类型，那么拷贝的时候这个引用类型是不会生成新的，这时原对象和拷贝对象的引用属性都会指向同一个对象，所以对原对象或拷贝对象的引用属性做出改变都会影响到彼此。看下面一张图可能会好理解一些
SourceObject对象有两个属性，一个是field1，这个属性是基本类型或String类型的，一个是refObj，refObj属性是引用类型的，对SourceObject对象再进行浅拷贝的时候生成了CopiedObject对象，可以看出CopiedObject的field2所指向的和field1不是同一个内存，而refObj属性却指向的是同一个内存。
2.深拷贝
对一个对象进行浅拷贝，会生成一个新的对象的同时也就将原对象的属性拷贝一份，注意这是一个新的对象，所以他们的内存地址是不一样的。不管原对象的属性是引用类型或是基本类型，都会开辟新的空间来存储这些属性，不会像浅拷贝那样，原对象和拷贝对象的引用类型属性都是指向同一个内存。所以对原对象或拷贝对象的属性改变都不会影响彼此。下面一张图是对深拷贝的描述
三.对clone方法的代码举例
package com.spring.ioc.test;
import java.util.ArrayList;
public class CloneTest {
public static void main(String[] args) {
School school = new School("红楼梦", "大观园", "丫鬟");
ArrayList<String> classmates = new ArrayList<String>();
classmates.add("林黛玉");
classmates.add("薛宝钗");
GirlFriend girlFriend = new GirlFriend("袭人", 18, 110, school,
classmates);
System.out.println("原对象girlFriend未变之前 ："
+ girlFriend.toString());
// 调用clone方法进行拷贝
GirlFriend girlFriendClone = girlFriend.clone();
System.out.println("克隆对象girlFriendTwo未变之前："
+ girlFriendClone.toString());
System.out.println("原对象girlFriend和克隆对象girlFriendTwo是否指向的内存地址相同："
+ (girlFriend == girlFriendClone));
System.out
.println("原对象girlFriend和克隆对象girlFriendTwo的school属性是否指向的内存地址相同："
+ (girlFriend.getSchool() == girlFriendClone
.getSchool()));
System.out
.println("原对象girlFriend和克隆对象girlFriendTwo的classmates属性是否指向的内存地址相同："
+ (girlFriend.getClassmates() == girlFriendClone
.getClassmates()));
System.out.println("*****************对克隆对象做操作*********************");
// 对基本类型和String类型做出改变
girlFriendClone.setName("湘云");
girlFriendClone.setAge(20);
girlFriendClone.setWeight(new Integer(115));
// 对引用类型属性做出改变
school.setProfession("小妾");
classmates.add("妙玉");
//girlFriendClone.setSchool(school);
System.out.println("原对象girlFriend改变之后： "
+ girlFriend.toString());
System.out.println("克隆对象girlFriendTwo改变之后："
+ girlFriendClone.toString());
}
}
class GirlFriend implements Cloneable {
private String name;
private int age;
private Integer weight;
// 引用类型属性
private School school;
// 引用类型属性
private ArrayList<String> classmates;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Integer getWeight() {
return weight;
}
public void setWeight(Integer weight) {
this.weight = weight;
}
public School getSchool() {
return school;
}
public void setSchool(School school) {
this.school = school;
}
public ArrayList<String> getClassmates() {
return classmates;
}
public void setClassmates(ArrayList<String> classmates) {
this.classmates = classmates;
}
// 重写clone方法
@SuppressWarnings("unchecked")
public GirlFriend clone() {
GirlFriend cirlFriend = null;
try {
cirlFriend = (GirlFriend) super.clone();
//cirlFriend.school = school.clone();
//cirlFriend.classmates = (ArrayList<String>) classmates.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return cirlFriend;
}
public GirlFriend(String name, int age, Integer weight, School school,
ArrayList<String> classmates) {
super();
this.name = name;
this.age = age;
this.weight = weight;
this.school = school;
this.classmates = classmates;
}
@Override
public String toString() {
return "GirlFriend [name=" + name + ", age=" + age + ", weight="
+ weight + ", school=" + school + ", classmates=" + classmates
+ "]";
}
public GirlFriend() {
}
}
class School implements Cloneable {
private String schoolName;
private String adress;
private String profession;
public String getSchoolName() {
return schoolName;
}
public void setSchoolName(String schoolName) {
this.schoolName = schoolName;
}
public String getAdress() {
return adress;
}
public void setAdress(String adress) {
this.adress = adress;
}
public String getProfession() {
return profession;
}
public void setProfession(String profession) {
this.profession = profession;
}
@Override
public String toString() {
return "School [schoolName=" + schoolName + ", adress=" + adress
+ ", profession=" + profession + "]";
}
public School(String schoolName, String adress, String profession) {
super();
this.schoolName = schoolName;
this.adress = adress;
this.profession = profession;
}
public School clone() {
School school = null;
try {
school = (School) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return school;
}
}
控制台打印信息
原对象girlFriend未变之前 ：GirlFriend [name=袭人, age=18, weight=110, school=School [schoolName=红楼梦, adress=大观园, profession=丫鬟], classmates=[林黛玉, 薛宝钗]]
克隆对象girlFriendTwo未变之前：GirlFriend [name=袭人, age=18, weight=110, school=School [schoolName=红楼梦, adress=大观园, profession=丫鬟], classmates=[林黛玉, 薛宝钗]]
原对象girlFriend和克隆对象girlFriendTwo是否指向的内存地址相同：false
原对象girlFriend和克隆对象girlFriendTwo的school属性是否指向的内存地址相同：true
原对象girlFriend和克隆对象girlFriendTwo的classmates属性是否指向的内存地址相同：true
*****************对克隆对象做操作*********************
原对象girlFriend改变之后： GirlFriend [name=袭人, age=18, weight=110, school=School [schoolName=红楼梦, adress=大观园, profession=小妾], classmates=[林黛玉, 薛宝钗, 妙玉]]
克隆对象girlFriendTwo改变之后：GirlFriend [name=湘云, age=20, weight=115, school=School [schoolName=红楼梦, adress=大观园, profession=小妾], classmates=[林黛玉, 薛宝钗, 妙玉]]
可以看到现在所重写的clone方法是一个浅拷贝。虽然是浅拷贝，但是拷贝生成的对象是一个新的对象，对拷贝对象的基本类型属性进行操作是不会影响原对象的基本类型属性的，如果是对拷贝对象的引用类型属性进行操作，是会影响到原对象的引用类型属性的。
如果我们想对原对象做出深拷贝，我们还得对原对象的引用类型进行拷贝,我们对以上代码做出一点改变，去掉GirlFriend类的clone方法中的注释，让clone方法变成深拷贝。
public GirlFriend clone() {
GirlFriend cirlFriend = null;
try {
cirlFriend = (GirlFriend) super.clone();
cirlFriend.school = school.clone();
cirlFriend.classmates = (ArrayList<String>) classmates.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return cirlFriend;
}控制台打印信息
原对象girlFriend未变之前 ：GirlFriend [name=袭人, age=18, weight=110, school=School [schoolName=红楼梦, adress=大观园, profession=丫鬟], classmates=[林黛玉, 薛宝钗]]
克隆对象girlFriendTwo未变之前：GirlFriend [name=袭人, age=18, weight=110, school=School [schoolName=红楼梦, adress=大观园, profession=丫鬟], classmates=[林黛玉, 薛宝钗]]
原对象girlFriend和克隆对象girlFriendTwo是否指向的内存地址相同：false
原对象girlFriend和克隆对象girlFriendTwo的school属性是否指向的内存地址相同：false
原对象girlFriend和克隆对象girlFriendTwo的classmates属性是否指向的内存地址相同：false
*****************对克隆对象做操作*********************
原对象girlFriend改变之后： GirlFriend [name=袭人, age=18, weight=110, school=School [schoolName=红楼梦, adress=大观园, profession=小妾], classmates=[林黛玉, 薛宝钗, 妙玉]]
克隆对象girlFriendTwo改变之后：GirlFriend [name=湘云, age=20, weight=115, school=School [schoolName=红楼梦, adress=大观园, profession=丫鬟], classmates=[林黛玉, 薛宝钗]]
可以看出无论是对基本属性还是对引用类型属性做出改变，都不会影响彼此，这就是深拷贝。
不过我有个疑问的地方是上面中weight的类型的Integer，应该是引用类型的，但是它和int类型的age的变化是一样的，不知道为什么？
四.总结
1.不管是浅拷贝还是深拷贝都会生成一个新的对象。
2.浅拷贝和深拷贝的主要区别在与拷贝对象的属性是引用类型还是基本类型，如果是引用类型，浅拷贝后两个对象的引用类型属性都是指向同一个内存地址；深拷贝后两个对象的引用类型属性指向的是不同的内存地址，说明引用类型属性也生成了新的，浅拷贝和深拷贝对于基本类型的属性都是生成新的。
3.如果不对clone方法做特别的操作的话，clone方法就是浅拷贝。
4.重写cloen方法要实现Cloneable接口。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
