Java 对象clone

package com.dashu.bean;
import lombok.Data;
import lombok.experimental.Accessors;
import java.io.Serializable;
/**
 * @Auther: DaShu
 * @Date: 2021/7/22 16:07
 * @Description:
 */
@SuppressWarnings("all")
@Accessors(chain = true)
@Data
public class Animal implements Cloneable, Serializable {
    private int age;
    private String name;
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

package com.dashu.bean;
import lombok.Data;
import lombok.experimental.Accessors;
import java.io.Serializable;
/**
 * @Auther: DaShu
 * @Date: 2021/7/22 16:07
 * @Description:
 */
@SuppressWarnings("all")
@Accessors(chain = true)
@Data
public class Cat implements Cloneable, Serializable {
    private int age;
    private String name;
    private Animal animal;
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

package com.dashu.bean;
import lombok.Data;
import lombok.experimental.Accessors;
/**
 * @Auther: DaShu
 * @Date: 2021/7/22 15:16
 * @Description:
 */
@SuppressWarnings("all")
@Accessors(chain = true)
@Data
public class Student implements Cloneable {
    private int age;
    private String name;
    private String[] addr;
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

package com.dashu.application;
import com.dashu.bean.Animal;
import com.dashu.bean.Cat;
import com.dashu.bean.Student;
import org.junit.jupiter.api.Test;
import java.io.*;
/**
 * @Auther: DaShu
 * @Date: 2021/7/22 15:06
 * @Description:
 */
@SuppressWarnings("all")
public class Sample {
    /*
     * @Target: 浅克隆
     * @Author: DaShu
     * @Date: 2021/7/22 15:07
     * @Result:
     */
    @Test
    public void testOne() throws CloneNotSupportedException {
        /**浅克隆对象的结论：
         * 1、实现步骤：
         *      （1）克隆对象必须实现Clonable接口，重写Object的clone()
         *      （2）克隆对象.clone()即可完成克隆，返回值是Object类型。
         * 2、克隆结论：
         *      （1）克隆新对象与原始对象地址值不同。
         *      （2）克隆对象中包含引用类型对象的，引用类型对象与原始对象中的完全一致。
         *       ps比如本次克隆中，字符串和数组对象引用类型完全一致。
         * 3、浅克隆本质：
         *      （1）创建一个新的对象，将新对象中的属性完全不改的拿过来。
         * 4、为什么需要重写clone方法？不重写会怎样？
         *      （1）本质也是调用的Object中的clone方法，为了扩大访问权限，可以访问的到，不写的话在Sample中没有访问权限编译报错！
         * */
        Student student = new Student();
        student.setAge(18).setName("tree").setAddr(new String[]{"北京", "上海"});
        Student clone = (Student) student.clone();
    }
    /*
     * @Target: 多重浅克隆尝试
     * @Author: DaShu
     * @Date: 2021/7/22 16:06
     * @Result:
     */
    @Test
    public void testTwo() throws CloneNotSupportedException {
        /**多重浅克隆对象的结论：
         *
         * 2、克隆结论：
         *      （1）克隆新对象与原始对象地址值不同。
         *      （2）克隆对象中包含引用类型对象的，引用类型对象与原始对象中的完全一致。
         * 总结：不管对象有多深，除了最外层地址换了，内部引用地址都没变，就是简单的copy过来了。
         * */
        Animal animal = new Animal();
        animal.setAge(100).setName("动物");
        Cat cat = new Cat();
        cat.setAge(12).setName("猫").setAnimal(animal);
        Cat clone = (Cat) cat.clone();
        animal.setName("dongwu");
    }
    /*
     * @Target: 深克隆
     * @Author: DaShu
     * @Date: 2021/7/22 16:06
     * @Result:
     */
    @Test
    public void testThree() throws CloneNotSupportedException, IOException, ClassNotFoundException {
        /**深克隆对象的结论：
         * 1、实现前提：对象以及对象中的引用类型必须都实现序列化接口，有一个没实现，就会报错。
         * 2、克隆结论：
         *      （1）克隆新对象与原始对象地址值不同。
         *      （2）克隆对象中包含引用类型对象的，引用类型对象与原始对象中的完全不同，彻底实现了新的对象的创建。
         * 总结：不管对象有多深，除了最外层地址换了，内部引用地址都会没变，并不是简单的copy，但是必须所有对象均实现序列化接口。
         * */
        Animal animal = new Animal();
        animal.setAge(100).setName("动物");
        Cat cat = new Cat();
        cat.setAge(12).setName("猫").setAnimal(animal);
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(cat);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
        Cat clone = (Cat) ois.readObject();
    }
}