-
引用拷贝
引用拷贝会生成一个新的对象引用地址，但是两个最终指向依然是同一个对象
引用拷贝.png
class Son {
String name;
int age;
public Son(String name, int age) {
this.name = name;
this.age = age;
}
}
public class test {
public static void main(String[] args) {
Son s1 = new Son("son1", 12);
Son s2 = s1;
s1.age = 22;
System.out.println(s1);
System.out.println(s2);
System.out.println("s1的age:" + s1.age);
System.out.println("s2的age:" + s2.age);
System.out.println("s1==s2" + (s1 == s2));//相等
}
}
-
浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。
浅拷贝.png
浅拷贝实现：就是在需要拷贝的类上实现Cloneable接口并重写其clone()方法
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
在使用的时候直接调用类的clone()方法即可。具体案例如下：
class Father{
String name;
public Father(String name) {
this.name=name;
}
@Override
public String toString() {
return "Father{" +
"name='" + name + '\'' +
'}';
}
}
class Son implements Cloneable {
int age;
String name;
Father father;
public Son(String name,int age) {
this.age=age;
this.name = name;
}
public Son(String name,int age, Father father) {
this.age=age;
this.name = name;
this.father = father;
}
@Override
public String toString() {
return "Son{" +
"age=" + age +
", name='" + name + '\'' +
", father=" + father +
'}';
}
@Override
protected Son clone() throws CloneNotSupportedException {
return (Son) super.clone();
}
}
public class test {
public static void main(String[] args) throws CloneNotSupportedException {
Father f=new Father("bigFather");
Son s1 = new Son("son1",13);
s1.father=f;
Son s2 = s1.clone();
System.out.println(s1);
System.out.println(s2);
System.out.println("s1==s2:"+(s1 == s2));//不相等
System.out.println("s1.name==s2.name:"+(s1.name == s2.name));//相等
System.out.println();
//但是他们的Father father 和String name的引用一样
s1.age=12;
s1.father.name="smallFather";//s1.father引用未变
s1.name="son222";//类似 s1.name=new String("son222") 引用发生变化
System.out.println("s1.Father==s2.Father:"+(s1.father == s2.father));//相等
System.out.println("s1.name==s2.name:"+(s1.name == s2.name));//不相等
System.out.println(s1);
System.out.println(s2);
}
}
不出意外，这种浅拷贝除了对象本身不同以外，各个零部件和关系和拷贝对象都是相同的，就好像双胞胎一样，是两个人，但是其开始的样貌、各种关系(父母亲人)都是相同的。需要注意的是其中name初始==是相等的，是因为初始浅拷贝它们指向一个相同的String，而后 s1.name="son222" 则改变引用指向。
- 深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。
对于上述的问题虽然拷贝的两个对象不同，但其内部的一些引用还是相同的，怎么样绝对的拷贝这个对象，使这个对象完全独立于原对象呢？就使用我们的深拷贝了。深拷贝：在对引用数据类型进行拷贝的时候，创建了一个新的对象，并且复制其内的成员变量。
深拷贝.png
在具体实现深拷贝上，重写clone()方法
重写clone()方法
如果使用重写clone()方法实现深拷贝，那么要将类中所有自定义引用变量的类也去实现Cloneable接口实现clone()方法。对于字符类可以创建一个新的字符串实现拷贝。
对于上述代码，Father类实现Cloneable接口并重写clone()方法。son的clone()方法需要对各个引用都拷贝一遍。
//Father clone()方法
@Override
protected Father clone() throws CloneNotSupportedException {
return (Father) super.clone();
}
//Son clone()方法
@Override
protected Son clone() throws CloneNotSupportedException {
Son son= (Son) super.clone();//待返回克隆的对象
son.name=new String(name);
son.father=father.clone();
return son;
}
其他代码不变，执行结果如下：
Son{age=13, name='son1', father=Father{name='bigFather'}}
Son{age=13, name='son1', father=Father{name='bigFather'}}
s1==s2:false
s1.name==s2.name:false
s1.Father==s2.Father:false
s1.name==s2.name:false
Son{age=12, name='son222', father=Father{name='smallFather'}}
Son{age=13, name='son1', father=Father{name='bigFather'}}
浅拷贝和深拷贝.png
