浅克隆和深克隆

•浅复制与深复制概念
–浅复制（浅克隆）：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

–深复制（深克隆）：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

Java的clone()方法【定义在Object类中】
–clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
–①对任何的对象x，都有x.clone() !=x
•克隆对象与原对象不是同一个对象
–②对任何的对象x，都有x.clone().getClass()= =x.getClass()
•克隆对象与原对象的类型一样
–③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。equals()方法定义恰当,即是说你重写了这个方法.

 

•Java中对象的克隆
–①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。
–②在派生类中覆盖基类的clone()方法，并声明为public【Object类中的clone()方法为protected的】。
–③在派生类的clone()方法中，调用super.clone()。
–④在派生类中实现Cloneable接口。

重要说明:

–①为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？
•在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。
–②继承自java.lang.Object类的clone()方法是浅复制

浅复制的例子:

public class CloneTest1 {
 public static void main(String[] args) throws Throwable {
  Student student=new Student();
  student.setAge(20);
  student.setName("zhangsan");
  
  Student student2=(Student)student.clone();
  System.out.println(student2.getAge()+","+student2.getName());
 }
}

class Student implements Cloneable{
 private int age;
 private String name;
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 @Override
 public  Object clone() throws CloneNotSupportedException {
  Object obj=super.clone();//继承自java.lang.Object类的clone()方法是浅复制
  return obj;
 }
}

深复制的例子:

public class CloneTest2 {
 public static void main(String[] args) throws Exception {
  Teacher t=new Teacher();
  t.setAge(30);
  t.setName("Teacher zhang");
  
  Student2 s1=new Student2();
  s1.setAge(20);
  s1.setName("zhang san");
  s1.setTeacher(t);
  
  Student2 s2=(Student2)s1.clone();
  t.setName("Teacher li");
  System.out.println(s2.getTeacher().getName());
 }
}
class Teacher implements Cloneable{//你要复制的引用的那个对象所在的类也要进行拷贝
 private int age;
 private String name;
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 @Override
 public  Object clone() throws CloneNotSupportedException {
  Object obj=super.clone();
  return obj;
  
 }
}
class Student2 implements Cloneable{
 private int age;
 private String name;
 private Teacher teacher;
 
 public Teacher getTeacher() {
  return teacher;
 }
 public void setTeacher(Teacher teacher) {
  this.teacher = teacher;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 @Override
 public  Object clone() throws CloneNotSupportedException {
  Student2 student2=(Student2)super.clone();
  student2.setTeacher((Teacher)teacher.clone());
  return student2;
 }
}

如果很多对象的话采用Object的clone方法很麻烦,则采用序列化的方式去深克隆,即先写到流里,然后再读出来一个Object.这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。

public class CloneTest3 {
 public static void main(String[] args) throws Exception {
  Teacher3 t=new Teacher3();
  t.setAge(40);
  t.setName("Teacher zhang");
  
  Student3 s=new Student3();
  s.setAge(20);
  s.setName("zhang san");
  s.setTeacher3(t);
  
  Student3 s1=(Student3)s.deepCopy();
  
  System.out.println(s1.getName());
  System.out.println(s1.getTeacher3().getName());
  
  t.setName("Teacher li");
  
  System.out.println("----------------------------");
  System.out.println(s.getTeacher3().getName());
  System.out.println(s1.getName());
  System.out.println(s1.getTeacher3().getName());
 }
 
}
class Teacher3 implements Serializable{

 private static final long serialVersionUID = -6344084449300091440L;
 private int age;
 private String name;
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
}
class Student3 implements Serializable{

 private static final long serialVersionUID = -4406799347300764992L;
 private int age;
 private String name;
 private Teacher3 teacher3;
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Teacher3 getTeacher3() {
  return teacher3;
 }
 public void setTeacher3(Teacher3 teacher3) {
  this.teacher3 = teacher3;
 }
 public Object deepCopy() throws Exception{
  //1.先写到流里面
  ByteArrayOutputStream bos=new ByteArrayOutputStream();
  ObjectOutputStream oos=new ObjectOutputStream(bos);
  oos.writeObject(this);
  oos.close();
  //2.从流里面读取出来
  ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray());
  ObjectInputStream ois=new ObjectInputStream(bis);
  Object obj=ois.readObject();
  ois.close();
  return obj;
 }
 
}