实现对象的深度克隆

1.方式一

实现Cloneable接口并重写 Object类中的 clone()方法

2. 方式二

(实现Serializable接口,通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆)

2.1 User类和Car的准备

package cn.qdm.ceshi;

import java.io.Serializable;

public class User  implements Serializable{
    private String name;
    private Integer age;
    
    private Car car; //开的车

    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 Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + ", car=" + car + "]";
    }

    public User(String name, Integer age, Car car) {
        super();
        this.name = name;
        this.age = age;
        this.car = car;
    }

    public User() {
        super();
        // TODO Auto-generated constructor stub
    }

}


package cn.qdm.ceshi;

import java.io.Serializable;

public class Car implements Serializable{
    private String brand; //品牌

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    @Override
    public String toString() {
        return "Car [brand=" + brand + "]";
    }

    public Car(String brand) {
        super();
        this.brand = brand;
    }

    public Car() {
        super();
        // TODO Auto-generated constructor stub
    }
    
}

2.2 克隆工具类的准备

package cn.qdm.ceshi;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class MyUtil {
    
    private MyUtil() {
        throw new AssertionError();
    }
    //实现深度克隆的工具方法
    
    public static<T extends Serializable> T clone(T obj) throws Exception{
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bout);
            oos.writeObject(obj);
            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bin);
            return (T) ois.readObject();
            //ByteArrayOutputStream和ByteArrayInputStream是基于内存的流只要垃圾回收器清理对象就能够释放资源，不同于外部资源(如文件流)的释放
            
    }
}

2.3 测试类

package cn.qdm.ceshi;

public class CloneTest {
    public static void main(String[] args) {
        User user1 = new User("张三", 18, new Car("BYD"));
        //深度克隆
        try {
            User user2 = MyUtil.clone(user1);
            //修改克隆对象user2的关联汽车属性
            user2.getCar().setBrand("迈凯伦P1");
            //打印原来对象不影响关联对象
            System.out.println(user1);
            System.out.println(user2);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

2.4 运行结果

3.注意：

基于序列化和反序列化实现的克隆不仅仅是深度克隆,更重要的是用过泛型限定,可以检查出
要克隆的对象是否支持序列化,这项检查是编译器完成的,不是在运行时抛出异常,这种方案明显
优于使用Obeject类的clone方法克隆对象,让问题在编译的时候就暴露出来

来源：https://www.cnblogs.com/qdmpky/p/11986437.html