java中的深拷贝和浅拷贝

1、浅拷贝
对源对象克隆到一个新的对象，源对象的引用类型按值副本传递，基本类型属性仍然引用之前的地址副本，所以对新对象修改引用类型属性时，
源对象也会被修改。
实现步骤：
    1）实现cloneable接口
    2）重写Object的clone方法
2、深拷贝
对源对象克隆到一个新的对象，新对象的基本类型和引用类型都会完整克隆一份新的，对新对象的引用类型修改不会影响到源对象。
实现方式：
    1）被克隆类和属性引用类型都实现cloneable接口并且重写Object的clone方法
    2）被克隆类和属性引用类型都实现Serializable接口,并定义深拷贝方法通过序列化和反序列化克隆完整对象

代码测试

被克隆类：Cat 

被引用类：Wing

测试类：CloneDemo

public class Cat implements Cloneable, Serializable {

    private static final String desc = "cue";
    private String name;
    private Wing wing;

    public Cat(String name, Wing wing) {
        this.name = name;
        this.wing = wing;
    }

    /**
     * 浅拷贝：实现Cloneable接口，调用父类Object的clone方法
     */
//    @Override
//    protected Object clone() throws CloneNotSupportedException {
//        return super.clone();
//    }

    /**
     * 深拷贝：所有引用类型属性实现Cloneable接口，调用属性clone方法赋值
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Cat cat = (Cat) super.clone();
        cat.wing = (Wing) wing.clone();
        return cat;
    }

    /**
     * 深拷贝：序列化和反序列化
     */
    protected Object deepClone() throws Exception {
        // 深拷贝
        // 序列化
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(this);

        // 反序列化
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bais);
        Object object = ois.readObject();
        return object;
    }

    public String getName() {
        return name;
    }

    public Wing getWing() {
        return wing;
    }

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

    public void setWing(Wing wing) {
        this.wing = wing;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                ", wing=" + wing +
                '}';
    }
}

class Wing implements Cloneable, Serializable {
    private String color;

    public Wing(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

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

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

}


class CloneDemo {

    public static void main(String[] args) throws Exception {
        Cat tom = new Cat("Tom", new Wing("blue"));
        // 调用父类Clone方法
        Cat clone = (Cat) tom.clone();
        clone.getWing().setColor("red");
        System.out.println("源对象：" + tom);
        System.out.println("调用Object的Clone方法：" + clone);

        // 序列化和反序列化深拷贝
        Cat cat = (Cat) tom.deepClone();
        cat.getWing().setColor("yellow");
        System.out.println("序列化反序列化方式：" + cat);
    }

}

标签：序列化,java,String,clone,Cat,拷贝,wing,public
来源： https://blog.csdn.net/weixin_41645232/article/details/113592522