天降大任于斯人也，必先苦其心志，劳其筋骨，饿其体肤
文章持续更新，可以微信搜索【小奇JAVA面试】第一时间阅读，回复【资料】更有我为大家准备的福利哟！回复【项目】有我为大家准备的一些项目源码。回复【简历模板】有我为大家准备的简历模板。

---

前言

白龙马，蹄朝西，驮着唐三藏和三徒弟，西天取经走大路，一走就是几万里。。。

想必这首歌大家都耳熟能详了吧，如果有感觉陌生的那你该补一补经典著作了。

小时候看到孙悟空每次人手不够的时候就拔一撮猴毛变出千千万万个猴子来，看到这里我就想着如果我也能变出来多个我来替我写作业就好了。

孙悟空变出的猴子跟他一模一样，但是这些猴子又是一个一个独立的个体，也就是说这些猴子受伤了对于真正的孙悟空来说并没有什么影响，相当于他对自己进行复制，只要原件不受损，复印件随便造。

那么我们今天来讲一讲设计模式中的原型模式是什么，前面已经介绍了其实原型就是孙悟空本身， 而他的变出来的猴子就是复印件。

一、面试

面试官：你可以说一下设计模式中的原型模式吗？

我：原型模式是一种特殊的创建型模式，它通过复制一个已有对象来获取更多相同或者相似的对象。原型模式可以提高相同类型对象的创建效率，简化创建过程。

面试官：原型模式主要是用来干什么的？

我：使用原型实例指定待创建对象的类型，并且通过复制这个原型来创建新的对象，说白了就是将一个原来的对象复制成另一个对象。

面试官：原型模式有哪些角色呢？

我：原型模式有3种角色。

1、Prototype（抽象原型类）：它是声明克隆方法的接口，是所有具体原型类的公共父类，它可以是抽象类也可以是接口，甚至还可以是具体实现类。

2、ConcretePrototype（具体原型类）：它实现在抽象原型类中声明的克隆方法，在克隆方法中返回自己的一个克隆对象。

3、Client（客户类）：在客户类中，让一个原型对象克隆自身从而创建一个新的对象，只需要直接实例化或通过工厂方法等方式创建一个原型对象，再通过调用该对象的克隆方法即可得到多个相同的对象。由于客户类针对抽象原型类Prototype编程，因此用户可以根据需要选择具体原型类，系统具有较好的可扩展性，增加或更换具体原型类都很方便。

面试官：什么是浅克隆，什么又是深克隆呢？

我：首先说一下对象中可以有基本数据类型和引用数据类型，如果是基本数据类型的话使用浅克隆就可以克隆出来一个独立的个体，如果是引用数据类型就无法克隆出一个独立的个体，这个时候就需要用到深克隆。

面试官：你可以写一个原型的案例吗？

1、首先创建一个抽象原型类

public abstract class ProtoType {
    public abstract ProtoType clone();
}
1
2
3

2、然后创建一个具体原型类

public class ConcretePrototype extends ProtoType {
    private String name;    //成员变量

    public String getName() {
        return name;
    }

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

    @Override
    public ProtoType clone() {
        ProtoType protoType = new ConcretePrototype();  //创建新对象
        ((ConcretePrototype) protoType).setName(this.name);
        return protoType;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3、然后创建一个客户类

public class Client {
    public static void main(String[] args) {
        ConcretePrototype prototype = new ConcretePrototype();
        prototype.setName("孙悟空");
        ConcretePrototype clone = (ConcretePrototype)prototype.clone();
        System.out.println(clone.getName());
    }
}
1
2
3
4
5
6
7
8

面试官：你这个是自己写的克隆方法，可以使用java中自带的克隆方法吗？

我：在java中Object类提供了一个clone()方法，可以将一个java对象复制一份，因此可以使用clone()方法来实现对象的克隆，不过这里要注意，这个方法只能实现浅克隆。而且要使用这个方法就需要实现Cloneable接口。

1、具体克隆类实现Cloneable接口

public class ConcretePrototype implements Cloneable{
    @Override
    public Object clone() {
        Object object = null;
        try {
            object = super.clone(); //浅克隆
        }catch (CloneNotSupportedException exception){
            System.err.println("Not support cloneable");
        }
        return object;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

2、客户类用来测试是否能够克隆

public class Client {
    public static void main(String[] args) {
        ConcretePrototype prototype = new ConcretePrototype();
        ConcretePrototype copy = (ConcretePrototype)prototype.clone();
        System.out.println(prototype == copy);
    }
}
1
2
3
4
5
6
7

面试官：你上面说的是浅克隆的方法，那么我想要深克隆怎么办呢？

我：深克隆需要实现Serialization序列化方式来实现深克隆。序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个复制，而原对象仍然存在于内存中。通过序列化的方式不仅可以复制基础类型，还可以复制引用类型。

面试官：可以简单写一个深克隆的例子吗？

1、首先定义一个学生实体。

public class Student implements Serializable {
    private String name;
    private int age;

    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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2、然后定义一个老师实体，其中有自己写的深克隆方法

public class Teacher implements Serializable {
    private Student student;
    private String name;
    private String add;

    public Student getStudent() {
        return student;
    }

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

    public String getName() {
        return name;
    }

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

    public String getAdd() {
        return add;
    }

    public void setAdd(String add) {
        this.add = add;
    }

    //在对象中自定义克隆的方法
    public Teacher deepClone() throws IOException,ClassNotFoundException, OptionalDataException {
        //将对象写入流中
        ByteArrayOutputStream out  = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(out);
        oos.writeObject(this);
        //将对象从流中取出
        ByteArrayInputStream bis = new ByteArrayInputStream(out.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (Teacher) ois.readObject();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

3、编写测试类

public class ClientDeep {
    public static void main(String[] args) {
        Teacher t_proto,t_new = null;
        t_proto = new Teacher();    //创建原型对象
        Student student = new Student();    //创建学生对象
        t_proto.setStudent(student);    //将学生添加到老师中
        try {
            t_new = t_proto.deepClone();    //调用深克隆方法创建克隆对象
        }catch (Exception e){
            System.err.println("克隆失败！");
        }
        //比较两个老师对象
        System.out.println("老师对象是否相同："+ (t_proto == t_new));
        //比较老师中的两个学生是否相同
        System.out.println("学生对象是否相同："+ (t_proto.getStudent() == t_new.getStudent()));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

可以看到我们老师中引用的学生对象，原型和克隆出来的地址也不一样，证明我们已经实现了深克隆的操作

面试官：你回答的真是太好了，什么时候可以来上班？

我：等我档期吧。。。

二、总结

这里的相关内容还没有整理完毕，文章后面持续更新，建议收藏。

文章中涉及到的命令大家一定要像我一样每个都敲几遍，只有在敲的过程中才能发现自己对命令是否真正的掌握了。

如果觉得我的文章还不错的话就点个赞吧，另外可以微信搜索【小奇JAVA面试】第一时间阅读，回复【资料】更有我为大家准备的福利哟！回复【项目】有我为大家准备的一些项目源码。回复【简历模板】有我为大家准备的简历模板。