1、什么是原型模式

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式之一。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

2、前置知识（深拷贝&浅拷贝）

2.1 浅拷贝

创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原
有属性所指向的对象的内存地址。

2.2 深拷贝

创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

3、代码实现

3.1 通过Object中的clone方法实现浅拷贝

学生类：

public class Student implements Cloneable{ //学生类，要使用clone的话要实现Cloneable接口，否则会报错
    private String name; //学生姓名
    private int age; //学生年龄
    public Student(String name,int age){ //构造函数
        this.name=name;
        this.age=age;
    }
    public void get(){ //输出学生信息
        System.out.println("名字是："+name+"------年龄是："+age);
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

座位类：（每个座位一一对应一个学生）

public class Seat implements Cloneable{//座位类，每个座位和学生一一对应
    private int num; //座位号
    private Student student; //这个座位属于的学生
    public Seat(int num,Student student){
        this.num=num;
        this.student=student;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    @Override
    public Seat clone() {
        try {
            return (Seat) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

测试类：

public class Test2 {
    public static void main(String[] args) {
        Student s1 = new Student("TowsJel", 19);
        Seat seat1 = new Seat(1, s1);
        Seat clone = seat1.clone();
        System.out.println("复制后的对象和原对象是否是同一个？------"+(clone==seat1));
        System.out.println("------验证是浅拷贝------");
        System.out.println("seat1中的学生对象和clone中的学生对象是否是同一个？------"+(seat1.getStudent()==clone.getStudent()));
    }
}

运行结果如下：

大家会觉得，诶，这又会怎么样呢，浅拷贝不就是里面的引用对象没有复制一份而已吗，会影响什么吗？大家来想想，如果此时，我们要修改clone中学生的名字，是不是seat1中的名字也会发生修改了？换句话说，clone这个座位的名字和seat1这个座位的名字是不是就是同一个人了？大家想想，这合理嘛！显然不合理！

那么如果想通过深拷贝的方式实现原型模式应该怎么办呢？那就需要通过“对象流”的方式来实现了。

3.2 通过对象流来实现深拷贝

基于上述的学生类和座位类，我们写得以下测试类：

public class Test3 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Student stu = new Student("张三", 19);
        Seat s1 = new Seat(1,stu);
        //创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new
                FileOutputStream("C:\\Users\\Think\\Desktop\\b.txt"));
        //将s1对象写出到文件中
        oos.writeObject(s1);
        oos.close();
        //创建对象出入流对象
        ObjectInputStream ois = new ObjectInputStream(new
                FileInputStream("C:\\Users\\Think\\Desktop\\b.txt"));
        //读取对象
        Seat s2 = (Seat) ois.readObject();
        //判断stu对象和stu1对象是否是同一个对象
        System.out.println("stu和stu1是同一个对象？" + (s1.getStudent()==s2.getStudent()));
    }
}

显然，最后运行结果肯定不是同一个对象。因此我们通过对象流的方式实现了深拷贝。