（六）JAVA基础及提高篇浅克隆及完全克隆

浅拷贝只是Java提供的一种简单的拷贝机制，不便于直接使用。

clone()方法是使用Object类的clone()方法，但是该方法存在一个缺陷，它并不会将对象的所有属性全部拷贝过来，而是有选择性的拷贝，基本规则如下：

      1、 基本类型

         如果变量是基本很类型，则拷贝其值，比如int、float等。

      2、 对象

         如果变量是一个实例对象，则拷贝其地址引用，也就是说此时新对象与原来对象是公用该实例变量。

      3、 String字符串

         若变量为String字符串，则拷贝其地址引用。但是在修改时，它会从字符串池中重新生成一个新的字符串，原有紫都城对象保持不变。

      对于上面的解决方案还是存在一个问题，若我们系统中存在大量的对象是通过拷贝生成的，如果我们每一个类都写一个clone()方法，并将还需要进行深拷贝，新建大量的对象，这个工程是非常大的，这里我们可以利用序列化来实现对象的拷贝。

demo

---

入口类： 

package com.other;

import org.junit.Test;

/**
 * 浅克隆及使用序列化实现对象的完全克隆
 */
public class Client {
    /**
     * ---------浅层次克隆----------
     * @throws CloneNotSupportedException
     */
    @Test
    public void test1() throws CloneNotSupportedException {
        Cat cat = new Cat();
        cat.setName("加菲猫");
        cat.setAge(2);
        cat.setSex(1);
        cat.setOwer(new Ower("小丽",21,2));
        //小丽拥有一只加菲猫，加菲猫两岁，性别男

        Cat cat2 = (Cat) cat.clone();//进行克隆
        System.out.println(cat.toString());
        System.out.println(cat2.toString());
        //Cat{name='加菲猫', age=1, sex=0, ower=Ower{name='小丽', age=21, sex=2}}
        //Cat{name='加菲猫', age=1, sex=0, ower=Ower{name='小丽', age=21, sex=2}}

        //克隆后的猫叫波斯猫，3岁了，性别变为女，属主为小张
        cat2.setName("波斯猫");
        cat2.setAge(3);
        cat2.setSex(2);
        cat2.getOwer().setName("小张");
        cat2.getOwer().setAge(28);
        cat2.getOwer().setSex(1);

        //打印差异，克隆体波斯猫属主改变，影响到原体加菲猫的属主。说明是浅克隆，对象仅是引用。
        System.out.println(cat.toString());
        System.out.println(cat2.toString());
        //Cat{name='加菲猫', age=2, sex=1, ower=Ower{name='小张', age=28, sex=1}}
        //Cat{name='波斯猫', age=3, sex=2, ower=Ower{name='小张', age=28, sex=1}}


        //---------深层次克隆----------
        //利用序列化实现对象的拷贝

    }

    /**
     * ---------深层次克隆----------
     * 利用序列化实现对象的拷贝
     * @throws CloneNotSupportedException
     */
    @Test
    public void test2() throws CloneNotSupportedException {
        Cat cat = new Cat();
        cat.setName("加菲猫");
        cat.setAge(2);
        cat.setSex(1);
        cat.setOwer(new Ower("小丽",21,2));
        //小丽拥有一只加菲猫，加菲猫两岁，性别男

        Cat cat2 = (Cat) CloneUtils.clone(cat);//进行克隆
        System.out.println(cat.toString());
        System.out.println(cat2.toString());
        //Cat{name='加菲猫', age=1, sex=0, ower=Ower{name='小丽', age=21, sex=2}}
        //Cat{name='加菲猫', age=1, sex=0, ower=Ower{name='小丽', age=21, sex=2}}

        //克隆后的猫叫波斯猫，3岁了，性别变为女，属主为小张
        cat2.setName("波斯猫");
        cat2.setAge(3);
        cat2.setSex(2);
        cat2.getOwer().setName("小张");
        cat2.getOwer().setAge(28);
        cat2.getOwer().setSex(1);

        //打印差异，克隆体波斯猫属主改变，对原体加菲猫的属主完全无影响，属于完全克隆。
        System.out.println(cat.toString());
        System.out.println(cat2.toString());
        //Cat{name='加菲猫', age=2, sex=1, ower=Ower{name='小丽', age=21, sex=2}}
        //Cat{name='波斯猫', age=3, sex=2, ower=Ower{name='小张', age=28, sex=1}}




    }
}

克隆原型 猫 

package com.other;

import java.io.Serializable;

/**
 * Cloneable 一般只能实现浅克隆
 * Serializable 序列号，实现完全克隆
 */
public class Cat implements Cloneable , Serializable {
    private String name;
    private Integer age;
    private int sex;
    private Ower ower ;

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

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                ", ower=" + ower +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public Ower getOwer() {
        return ower;
    }

    public void setOwer(Ower ower) {
        this.ower = ower;
    }


}

猫属主 

package com.other;

import java.io.Serializable;

/**
 * 属主
 */
public class Ower implements Serializable {
    private String name ;
    private Integer age ;
    private int sex;

    public Ower(String name, Integer age, int sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Ower{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }
}

系列化克隆通用方法 

package com.other;

import java.io.*;

/**
 * 系列化克隆通用方法
 */
public class CloneUtils {
    public static <T extends Serializable> T clone(Cat obj){
        T cloneObj = null;

        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ObjectOutputStream obs = null;
        try {
            //写入字节流
            obs = new ObjectOutputStream(out);
            obs.writeObject(obj);
            obs.close();

            //分配内存，写入原始对象，生成新对象
            ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(ios);
            //返回生成的新对象
            cloneObj = (T) ois.readObject();
            ois.close();

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return cloneObj;
    }
}