在说这个问题之前，先看一段代码
public class Person {
public int num;
public String name;
}
public class Test4 {
public static void main(String[] args) {
Person p1 = new Person();
p1.num = 001;
p1.name = "张三";
Person p2 = p1; //关注点1
p2.name="李四";
System.out.println(p1 == p2);
System.out.println(p1.name);
}
}
输出结果
true
李四
结果分析
关注点1这句代码，是将p1对象的引用(地址)拷贝给了p2，因此p1和p2指向同一个地址，p2对这个地址对应的区域做了修改，p1访问这个地址时当然拿到的是修改后的内容。
调用clone方法
上代码之前，先说下调用该代码的必备条件
实现Cloneable接口，否则会抛CloneNotSupportedException异常
重写Object类的clone方法，否则调用不到该方法
这里有几个疑问
Object类的clone方法明明是protected的，为什么子类调不到？
网上说的要将clone方法声明为public？
修改代码如下
public class Book {
public String name;
}
public class Person implements Cloneable{
public int num;
public String name;
public Book book;
@Override
protected Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
}
public class Test4 {
public static void main(String[] args) throws CloneNotSupportedException {
//p1的属性
Person p1 = new Person();
Book book=new Book();
book.name="算法导论";
p1.num = 001;
p1.name = "张三";
p1.book=book;
//p2的属性
Person p2 = (Person) p1.clone();
p2.name="李四";
p2.book.name="操作系统";
System.out.println(p1 == p2);
System.out.println(p1.name);
System.out.println(p1.book==p2.book);
System.out.println(p1.book.name);
}
}
输出结果
false
张三
true
操作系统
结果分析
p2是p1的一个克隆，故p1和p2此时指向不同的地址
在克隆的时候，String类型和基本类型一样都会被克隆
因为Book是自定义的对象，故无法实现克隆(深拷贝)，即p1和p2中的book对象指向的是同一个地址。
不过这里我还有个疑问
String类也是对象类型的，它没有实现Clonable接口，也没有重写clone方法，是如何实现克隆的了？
为了实现彻底的克隆，我们来修改下Book和Person的代码
public class Person implements Cloneable{
public int num;
public String name;
public Book book;
@Override
protected Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
Person p=(Person) super.clone();
p.book=(Book) book.clone();
return p;
}
}
public class Book implements Cloneable{
public String name;
@Override
protected Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
}
输出结果
false
张三
false
算法导论
结果分析
在Person类的clone方法中，增加了book对象的克隆，因此p1和p2的book对象不再指向同一个地址了。
结论
Object类的clone方法只会对基本类型(对应的包装类)和String类型进行深拷贝，对于普通对象只是复制一下地址。
包装类虽然没有测试，但发现包装类是final型的，不可能继承重写clone方法，因此猜测它和String类一样是深拷贝。
想要完成彻底的深拷贝，需要对本类中的其他普通类依次调用它们的clone方法。
看了上面的叙述，不知道你是否会想，那如果我的A类包含B类，B类又包含C类.......，这样就需要对每一个类都做相应的处理，这样岂不是很费劲？别着急，下面我来介绍一下Serializable
Serializable深拷贝
public class Book1 implements Serializable{
private static final long serialVersionUID = 1L;
public String name;
}
public class Student implements Serializable{
private static final long serialVersionUID = 1L;
public int num;
public String name;
public Book1 book;
}
public static Object deepCopy(Object object){
ByteArrayOutputStream bo=null;
ObjectOutputStream oo=null;
ByteArrayInputStream bi=null;
ObjectInputStream oi=null;
Object obj=null;
try {
//将对象写入流
bo=new ByteArrayOutputStream();
oo=new ObjectOutputStream(bo);
oo.writeObject(object);
//从流中读取对象
bi=new ByteArrayInputStream(bo.toByteArray());
oi=new ObjectInputStream(bi);
obj=oi.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
if(oi!=null)
oi.close();
if(bi!=null)
bi.close();
if(oo!=null)
oo.close();
if(bo!=null)
bo.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return obj;
}
public class Test5 {
public static void main(String[] args) {
// s1的属性
Student s1 = new Student();
Book1 book = new Book1();
book.name = "算法导论";
s1.num = 001;
s1.name = "张三";
s1.book = book;
// s2的属性
Student s2 =(Student) Utils.deepCopy(s1);
s2.name = "李四";
s2.book.name = "操作系统";
System.out.println(s1 == s2);
System.out.println(s1.name);
System.out.println(s1.book == s2.book);
System.out.println(s1.book.name);
}
}
输出结果
false
张三
false
算法导论
结果分析
此结果与上面对person和book分别调用clone方法一致，说明serializable能够对对象做深拷贝，无论该对象里是否有其他普通对象。
回到最初的问题
浅拷贝，对于引用类型，只是对地址做了拷贝，即copy前后的对象指向的是同一块内存空间。
深拷贝，对于引用类型，会在内存空间新开辟一块空间，并将被拷贝的对象的相关属性一一复制在新的内存空间内，即copy前后的对象指向的是不同的内存空间。
