Cloneable实现对象克隆

在其他文章中已经说明了场景，和一些对象克隆的实现方式。本篇文章主要是对Cloneable接口如何实现对象克隆展开。

首先需要声明下，对象有分为浅克隆和深克隆。

浅克隆

浅克隆是对要克隆的对象，其中的基本类型复制一份新的产生给对象。但是对于非基本类型的数据类型，仅仅是复制一份引用给新产生的对象。即基本类型是新产生的，非基本类型是复制一份内存引用。

实现步骤：

1.实现Cloneable接口

要clone方法，为什么还要实现Cloneable接口呢？我们可以看看，Cloneable其中是一个空方法，他个RandomAccess一样

都属于，标识接口。针对的是Object里的clone方法，进行重写。告诉Object而已。如果调用了super.clone()方法。没有实现Cloneable接口。那么会抛出异常CloneNotSupportedException异常。

2.重写clone方法。

JDK中的API文档也说明了，这是一个对象拷贝的过程，不是对象的初始化过程。他包含了一些原有对象的信息。

Object中的clone的返回值是native。native属于一般是由C语言实现，效率一般都高于java代码，所以这里我们没有选择new一个新的对象，而是选择对象拷贝。

Object中的clone修饰符是protected，我们要把它改成public。

 实例代码如下：

bean：school，student。school中包含有student。main为执行方法。

student类如下：

package run;

public class student {
    private String gg;

    public String getGgg() {
        return gg;
    }

    public void setGgg(String ggg) {
        this.gg = ggg;
    }
    

    @Override
    public String toString() {
        return "student{" +
                "gg='" + gg + '\'' +
                '}';
    }


}

school类代码如下：

package run;

public class school implements Cloneable{
    private String name;
    private String age;
    private student st;

    public student getSt() {
        return st;
    }
    public void setSt(student st) {
        this.st = st;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "school{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", st=" + st.toString() +
                '}';
    }
}

main的执行方法：

package run;

public class main {

        public static void main(String args[]) throws CloneNotSupportedException {
                student b1 = new student();
                b1.setGgg("123");

                school school1 = new school();
                school1.setAge("11");
                school1.setName("lsp");
                school1.setSt(b1);

                school school2 = (school) school1.clone();
                school2.setAge("26");
               school2.getSt().setGgg("456");

                System.out.println(school1);
                System.out.println(school2);
        }


}

输出如下：

school{name='lsp', age='11', st=student{gg='456'}}
school{name='lsp', age='26', st=student{gg='456'}}

分析：通过输出可以看出，浅克隆对于基本类型数据，已经完成了克隆，但是对于非基本类型数据还是指向同一个内存地址。

 

深克隆

深度克隆，其实就是对于浅度克隆的一种完善，浅度克隆只能完成基本类型的克隆，对于非基本类型无法克隆，只能复制内存地址到新的对象上。而深度克隆不同，深度克隆是完成了，基本数据类型和非基本数据类型，都可以克隆。

深度克隆：

要克隆的类和类中所有非基本类型对应的类

1.都要实现java.lang.Cloneable接口。

2.都要重写java.lang.Object.clone（）方法。

3.在主类上添加子类的Clone方法。

 

 实例代码如下：

bean：school，student。school中包含有student。main为执行方法。

 

student类和浅克隆的区别在于，实现了Cloneable接口。重写了clone方法。

package run;

public class student implements Cloneable{
    private String gg;

    public String getGgg() {
        return gg;
    }

    public void setGgg(String ggg) {
        this.gg = ggg;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "student{" +
                "gg='" + gg + '\'' +
                '}';
    }


}

 

school类的clone方法是重点，它调用了子类的clone方法。所以才可以实现深度克隆。

package run;

public class school implements Cloneable{
    private String name;
    private String age;
    private student st;

    public student getSt() {
        return st;
    }
    public void setSt(student st) {
        this.st = st;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    @Override
    protected school clone() throws CloneNotSupportedException {
        school s = (school) super.clone();
        s.st= (student) st.clone();
        return s;
    }

    @Override
    public String toString() {
        return "school{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", st=" + st.toString() +
                '}';
    }
}

 

main方法执行没有改动：

package run;

public class main {

        public static void main(String args[]) throws CloneNotSupportedException {
                student b1 = new student();
                b1.setGgg("123");

                school school1 = new school();
                school1.setAge("11");
                school1.setName("lsp");
                school1.setSt(b1);

                school school2 = (school) school1.clone();
                school2.setAge("26");
               school2.getSt().setGgg("456");

                System.out.println(school1);
                System.out.println(school2);
        }


}

输出如下：

school{name='lsp', age='11', st=student{gg='123'}}
school{name='lsp', age='26', st=student{gg='456'}}

分析：通过上述代码输出，可以看到引用数据类型，互不影响了。

 

---

补充：

1.重写，重写的返回值可以是原返回值，或者原返回值类型的子类。

2.java的基本类型，byte，short，int，long，char，float，double，boolean。但是非基本类型比如，integer，stringbuffere。这些非基本数据类型的对象。让他们实现Cloneable并重写clone非常的麻烦。所以大多数情况下，程序员还是会选择使用序列化的方式，完成对象克隆。

3.另外clone的写法。

默认生成如下：

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

优化生成：

    @Override
    protected Object clone()   {
        try {
            return (student)super.clone();

        }catch (CloneNotSupportedException e){
            return null;
        }
    }