Java clone方法（下）

1.终于调用的是一个JNI方法，即java本地方法，加高速度

2.使用clone方法，分为浅复制、深复制，这里直接使用网上抄来的案例来说明吧：

说明：

　　1）为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？在执行时刻，Object中的clone()识别你要复制的是哪一个对象，然后为此对象分配空间。并进行对象的复制，将原始对象的内容一一拷贝到新对象的存储空间中。

　　2）继承自java.lang.Object.clone()方法是浅层复制。一下代码能够证明之：

public class Student implements Cloneable {
    private String name;
    private int age;
    private Professor pro;
    public Student(){}
    public Student(String name,int age,Professor pro){
        this.name=name;
        this.age=age;
        this.pro=pro;
    }
    public Object clone(){
        Object o=null;
        try {
            //Object中的clone()识别出你要复制的是哪一个对象。
            o=super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.toString());
        }
        return o;
    }
    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 Professor getPro() {
        return pro;
    }
    public void setPro(Professor pro) {
        this.pro = pro;
    }
}
class Professor{
    private String name;
    private int age;
    public Professor(){}
    public Professor(String name,int age){
        this.name=name;
        this.age=age;
    }
    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 class StudentTest {
    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.getPro().setName("maer");
        s2.getPro().setAge(40);
        System.out.println("name="+s1.getPro().getName()
                +",age="+s1.getPro().getAge());
        //name=maer,age=40
    }
}

　　那么我们怎样实现深层复制的克隆，即在改动s2.Professor时不影响s1.Professor？代码改进例如以下：

public class Student implements Cloneable {
    private String name;
    private int age;
    Professor pro;
    public Student(){}
    public Student(String name,int age,Professor pro){
        this.name=name;
        this.age=age;
        this.pro=pro;
    }
    public Object clone(){
        Student o=null;
        try {
            //Object中的clone()识别出你要复制的是哪一个对象。

            o=(Student)super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.toString());
        }
        o.pro=(Professor)pro.clone();
        return o;
    }
    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 Professor getPro() {
        return pro;
    }
    public void setPro(Professor pro) {
        this.pro = pro;
    }
}
class Professor implements Cloneable{
    private String name;
    private int age;
    public Professor(){}
    public Professor(String name,int age){
        this.name=name;
        this.age=age;
    }
    public Object clone(){
        Object o=null;
        try {
            o=super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }
    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 class StudentTest {
    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.getPro().setName("maer");
        s2.getPro().setAge(40);
        System.out.println("name="+s1.getPro().getName()
                +",age="+s1.getPro().getAge());
        //name=wangwu,age=50
    }
}

也就是说浅复制仅仅复制了一些主要的属性，可是里面的引用的属性并没有真正的复制，所以假设想要达到深复制，还要在复写的代码中进行处理。将全部引用的对象也都调用它们的clone（)方法。

下面是摘抄的网友的三点小总结：

clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
①对不论什么的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象
②对不论什么的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样
③假设对象x的equals()方法定义恰当。那么x.clone().equals(x)应该成立。

以下重点说一下，为什么String相同是对象。可是却不用特殊处理；理由例如以下：

String不是基本数据类型。可是在深复制的时候并没有进行单独的复制。也就是说违反了深复制，只复制了引用，而String没有实现cloneable接口，也就是说只能复制引用。

        那么在改动克隆之后的对象之后，会不会将原来的值也改变了？

        答案肯定是不会改变，由于String是在内存中不能够被改变的对象，就比方说在for大量循环中不推荐使用+的方式来拼凑字符串一样，每次使用+都会新分配一块内存，不在原来上改动，原来的没有指向它的引用，会被回收。所以克隆相当于1个String内存空间有两个引用，当改动当中的一个值的时候。会新分配一块内存用来保存新的值，这个引用指向新的内存空间，原来的String由于还存在指向他的引用，所以不会被回收，这样，尽管是复制的引用，可是改动值的时候，并没有改变被复制对象的值。

        所以在非常多情况下。我们能够把String在clone的时候和基本类型做同样的处理。仅仅是在equal时注意一些即可了。