使用序列化与反序列化方式克隆对象

实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下：

汽车类：

package com.tang.clone;

import java.io.Serializable;

/**
 * car类
 *
 * @author tangyifei
 * @date 2019年8月21日14:24:38
 */
public class Car implements Serializable {

    private static final long serialVersionUID = 6303629656112016967L;

    private String brand;

    private int maxSpeed;

    public Car(String brand, int maxSpeed) {
        this.brand = brand;
        this.maxSpeed = maxSpeed;
    }

    public String getBrand() {
        return brand;
    }

    public int getMaxSpeed() {
        return maxSpeed;
    }

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

    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", maxSpeed=" + maxSpeed +
                '}';
    }
}

person类：

package com.tang.clone;

import java.io.Serializable;

/**
 * person类
 *
 * @author tangyifei
 * @date 2019年8月21日14:23:26
 */
public class Person implements Serializable {

    private static final long serialVersionUID = -4093651074329191599L;

    private String name;

    private int age;

    private Car car;

    public Person(String name, int age, Car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Car getCar() {
        return car;
    }

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

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

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

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

克隆工具类：

package com.tang.clone;

import java.io.*;

/**
 * 执行深度克隆对象的工具类
 *
 * @author tangyifei
 * @date 2019年8月21日14:22:26
 */
public class MyUtil {

    private MyUtil() {
        throw new AssertionError();
    }

    @SuppressWarnings("unchecked")
    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();
        // 说明：调用 ByteArrayInputStream 或 ByteArrayOutputStream 对象的 close 方法没有任何意义
        // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源（如文件流）的释放
    }


}

测试类：

package com.tang.clone;

/**
 * 执行测试
 *
 * @author tangyife
 * @date 2019年8月21日14:28:09
 */
public class CloneTest {

    public static void main(String[] args) {
        Person person1 = new Person("tangyifei", 23, new Car("宝马", 250));
        try {
            Person person2 = MyUtil.clone(person1);
            person2.getCar().setBrand("奔驰");
            // 修改克隆的 Person 对象 p2 关联的汽车对象的品牌属性
            // 原来的 Person 对象 p1 关联的汽车不会受到任何影响
            // 因为在克隆 Person 对象时其关联的汽车对象也被克隆了
            System.out.println(person1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行上面的测试类，运行结果如下：
Person{name=‘tangyifei’, age=23, car=Car{brand=‘宝马’, maxSpeed=250}}

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