Java中的克隆

Java中的克隆

1.为什么要使用克隆，对象的引用赋值不是也可以吗，下面会给出证明

首先定义一个Student类

public class Student implements Cloneable{

    private String studentName;

    private int age;

    public int getAge() {

      return age;

  }

  public void setAge(int age) {

      this.age = age;

  }

  public String getStudentName() {

      return studentName;

  }

  public void setStudentName(String studentName) {

      this.studentName = studentName;

  }

}

入口函数：

public static void main(String args[]){

      Student student0 = new Student();   

      student0.setStudentName("xiaoming");     

      Student student1 = student0;

      System.out.println("student0.getStudentName:"+student0.getStudentName());

      System.out.println("student1.getStudentName:"+student1.getStudentName());

}

运行结果：打印输出：

student0.getStudentName:xiaoming

student1.getStudentName:xiaoming

在入口函数中student0 被付给了student1两引用指向了内存中的同一块空间，所以通过student0对对象的操作与通过student1对对象的操作完全一致。

有时候需要创造一个student0的副本，内容与student0完全一致，但是以后可以根据需要对student1内容修改，而不会影响到student0,这时候我们就需要用到clone.

虽然Clone方法在Object中存在的，但是如果想要调用clone必须实现Cloneable接口，否则会抛出java.lang.CloneNotSupportedException。

看一下实例

public class Student implements Cloneable{

  private String studentName;

  private int age; 

  public int getAge() {

    return age;

  }

  public void setAge(int age) {

      this.age = age;

  }

  public String getStudentName() {

      return studentName;

  }

  public void setStudentName(String studentName) {

      this.studentName = studentName;

  }

  public Object clone() throws CloneNotSupportedException { 

      Student student =  (Student) super.clone();

      return student; 

  }   

}

public static void main(String args[]){

      Student student = new Student();

      student.setAge(10);

      student.setStudentName("xiaobai");

      try {

          Student s1  = (Student) student.clone();

          s1.setStudentName("xiaohei");

          System.out.println("student.studentName:"+student.getStudentName());

          System.out.println("student.age:"+student.getAge());

          System.out.println("s1.studentName:"+s1.getStudentName());

          System.out.println("s1.age:"+s1.getAge());

 

      } catch (CloneNotSupportedException e) {

                    e.printStackTrace();

      } 

}

运行结果：

student.studentName:xiaobai

student.age:10

s1.studentName:xiaohei

s1.age:10

我们发现s1的studentName值得到了修改，但是student的studentName值没有受到影响，这就是clone的作用。使用起来很简单，只需要在需要clone的对象上实现（implements）Cloneable接口，然后再在类中加上clone方法，在方法中只需要调用super.clone()即可，如上例中的部分代码：Student student =  (Student)super.clone()，需要注意clone方法在当前类没有实现Cloneable的情况下可能抛出CloneNotSupportedException，所以我们需要对该异常进行处理。

2.总结Java的clone()方法
⑴clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
①对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象
②对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样
③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。
⑵Java中对象的克隆
①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。
②在派生类中覆盖基类的clone()方法，并声明为public。
③在派生类的clone()方法中，调用super.clone()。
④在派生类中实现Cloneable接口。

3.java中的深克隆与浅克隆

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

⑵深复制（深克隆）
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原

有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

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

class Professor   
{   
    String name;   
    int age;   
    Professor(String name,int age)   
    {   
        this.name=name;   
        this.age=age;   
    }   
}   
class Student implements Cloneable   
{   
    String name;// 常量对象。   
    int age;   
    Professor p;// 学生1和学生2的引用值都是一样的。   
    Student(String name,int age,Professor p)   
    {   
        this.name=name;   
        this.age=age;   
        this.p=p;   
    }   
    public Object clone()   
    {   
        Student o=null;   
        try   
        {   
            o=(Student)super.clone();   
        }   
        catch(CloneNotSupportedException e)   
        {   
            System.out.println(e.toString());   
        }   
        o.p=(Professor)p.clone();   
        return o;   
    }   
}   
public static void main(String[] args)   
    {   
      Professor p=new Professor("wangwu",50);   
      Student s1=new Student("zhangsan",18,p);   
      Student s2=(Student)s1.clone();   
      s2.p.name="lisi";   
      s2.p.age=30;   
      System.out.println("name="+s1.p.name+","+"age="+s1.p.age);//学生1的教授成为lisi,age为30。 
} 

那应该如何实现深层次的克隆，即修改s2的教授不会影响s1的教授？代码改进如下。
改进使学生1的Professor不改变（深层次的克隆）
class Professor implements Cloneable   
{   
    String name;   
    int age;   
    Professor(String name,int age)   
    {   
        this.name=name;   
        this.age=age;   
    }   
    public Object clone()   
    {   
        Object o=null;   
        try   
        {   
            o=super.clone();   
        }   
        catch(CloneNotSupportedException e)   
        {   
            System.out.println(e.toString());   
        }   
        return o;   
    }   
}   
class Student implements Cloneable   
{   
    String name;   
    int age;   
    Professor p;   
    Student(String name,int age,Professor p)   
    {   
        this.name=name;   
        this.age=age;   
        this.p=p;   
    }   
    public Object clone()   
    {   
        Student o=null;   
        try   
        {   
            o=(Student)super.clone();   
        }   
        catch(CloneNotSupportedException e)   
        {   
            System.out.println(e.toString());   
        }   
        o.p=(Professor)p.clone();   
        return o;   
    }   
}   
public static void main(String[] args)   
    {   
      Professor p=new Professor("wangwu",50);   
      Student s1=new Student("zhangsan",18,p);   
      Student s2=(Student)s1.clone();   
      s2.p.name="lisi";   
      s2.p.age=30;   
      System.out.println("name="+s1.p.name+","+"age="+s1.p.age);//学生1的教授不 改变。 
}   

4．利用串行化来做深复制

把对象写到流里的过程是串行化（Serilization）过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做 “解冻”或者“回鲜(depicking)”过程。

应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。
如下为深复制源代码。
public Object deepClone()   
{   
//将对象写到流里   
ByteArrayOutoutStream bo=new ByteArrayOutputStream();   
ObjectOutputStream oo=new ObjectOutputStream(bo);   
oo.writeObject(this);   
//从流里读出来   
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());   
ObjectInputStream oi=new ObjectInputStream(bi);   
return(oi.readObject());   
} 

这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。上例代码改进如下。
class Teacher implements Serializable{
String name;
int age;
Teacher(String name,int age){
this.name=name;
this.age=age;
}
}
class Student implements Serializable{
String name;//常量对象
int age;
Teacher t;//学生1和学生2的引用值都是一样的。
Student(String name,int age,Teacher t){
this.name=name;
this.age=age;
this.p=p;
}
public Object deepClone() throws IOException,
OptionalDataException,ClassNotFoundException{//将对象写到流里
ByteArrayOutoutStream bo=new ByteArrayOutputStream();
ObjectOutputStream oo=new ObjectOutputStream(bo);
oo.writeObject(this);//从流里读出来
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi=new ObjectInputStream(bi);
return(oi.readObject());
}

}
public static void main(String[] args){
Teacher t=new Teacher("tangliang",30);
Student s1=new Student("zhangsan",18,t);
Student s2=(Student)s1.deepClone();
s2.t.name="tony";
s2.t.age=40;
System.out.println("name="+s1.t.name+","+"age="+s1.t.age);//学生1的老师不改变
}

本文永久更新链接地址：