设计模式-原型模式 clone

原型模式有两种状态 浅拷贝与深拷贝

浅拷贝：创建一个新的对象，但是内部引用数据类型 指向的还是通一个地址，基本数据类型没有地址，类似于快捷方式

深拷贝：创建一个新的对象 ，引用数据类型指向的地址也是全新的 类似于副本

浅拷贝： 

package com.qf.prototypedemo.simpleclone;

//实现 Cloneable 接口
/*
浅拷贝 ： 创建一个新对象 非基本类型地址是一样的
三个角色：
 抽象原型类 规定必须实现的clone方法
具体原型类：实现抽象原型类 他是可被复制的对象
访问类： 使用 具体原型类 中的clone 去复制对象
 */

public class Realizetype implements Cloneable {
    private String name;
    private int id;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Realizetype() {
        System.out.println("具体原型对象创建完成");
    }

    @Override
    protected Realizetype clone() throws CloneNotSupportedException {
        System.out.println("具体原型复制成功");
        return (Realizetype) super.clone();
    }
}




package com.qf.prototypedemo.simpleclone;

public class PrototypeTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Realizetype r1 = new Realizetype();
        //复制对象 ->对象是不一样的 其中的 引用类型 是指向一个地址空间的
        Realizetype r2 = r1.clone();

        // 设置 具体值 去验证 基本数据类型与 引用数据类型 在浅拷贝上是不一样的
        r1.setName("zhangsan");
        r1.setId(1);
        System.out.println(r1.getName());
        System.out.println(r2.getName());
        System.out.println(r1.getId());
        System.out.println(r2.getId());
    }
}

深拷贝：

package com.qf.prototypedemo.deepclone;

import com.qf.prototypedemo.deepclone.pojo.Student;

import java.io.*;

//深克隆测试  进行深克隆需要使用对象流
public class DeepCloneTest {
//    public static void main(String[] args) throws CloneNotSupportedException {
//        //声明一个具体原型类
//        Citation c1 = new Citation();
//        Student s1 = new Student("张三", "二七");
//
//        //将原型类的学生属性设置对象
//        c1.setStu(s1);
//
//        //克隆 奖状类
//        Citation c2 = (Citation) c1.clone();
//        Student s2 = c2.getStu();
//        s2.setName("李四");
判断stu对象和stu1对象是否是同一个对象
//        System.out.println("stu和stu1是同一个对象？" + (s1 == s2));
//
//        c1.show();
//        c2.show();
//
//    }

    //深克隆
    public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException {
        //声明一个具体原型类
        Citation c1 = new Citation();
        Student stu1 = new Student("张三", "二七");
        c1.setStu(stu1);

        //创建对象输出流 写入磁盘
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("E:\\Temp\\work\\beepclone.txt"));
        //将对象写入磁盘
        out.writeObject(c1);
        out.close();

        //创建对象输入流 写入程序
        ObjectInputStream into = new ObjectInputStream(new FileInputStream("E:\\Temp\\work\\beepclone.txt"));
        //读取对象
        Citation c2 = (Citation) into.readObject();
        //获取c2 奖状对象 所属的学生类对象
        Student stu2 = c2.getStu();
        stu2.setName("李四");

        System.out.println("两个对象是否是 一个对象" + (stu1 == stu2));
        c1.show();
        c2.show();

    }
}



package com.qf.prototypedemo.deepclone;

//深拷贝 奖状类

import com.qf.prototypedemo.deepclone.pojo.Student;

import java.io.Serializable;

/**
 * 拷贝一个新对象 ，对象内所有数据 都是另一份 相当于副本
 */
public class Citation implements Cloneable, Serializable {

    //学生类属性
    private Student stu;


    public Student getStu() {
        return stu;
    }

    public void setStu(Student stu) {
        this.stu = stu;
    }

    //show 方法
    void show() {
        System.out.println(stu.getName() + "同学：在2020学年第一学期中表现优秀，被评为三好学生。特发此状！");
    }

    //重写拷贝方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}