乐趣区

重学-Java-设计模式实战原型模式

jiezi

作者：小傅哥
博客：https://bugstack.cn

沉淀、分享、成长，让自己和他人都能有所收获！?

一、前言

老板你加钱我的代码能飞

程序员这份工作里有两种人；一类是热爱喜欢的、一类是仅当成工作的。而喜欢代码编程的这部分人会极其主动学习去丰富自己的羽翼，也非常喜欢对技术探索力求将学到的知识赋能到平时的业务需求开发中。对于这部分小伙伴来说上班写代码还能赚钱真的是幸福！

怎么成为喜欢编码都那部分人

无论做哪行那业你都喜欢，往往来自从中持续不断都获取成就感。就开发编程而言因为你的一行代码影响到了千千万万的人、因为你的一行代码整个系统更加稳定、因为你的一行代码扛过了所有秒杀等等，这样一行行的代码都是你日积月累学习到的经验。那如果你也想成为这样有成就感的程序员就需要不断的学习，不断的用更多的技能知识把自己编写的代码运用到更核心的系统。

方向不对努力白费

平常你也付出了很多的时间，但就是没有得到多少收益。就像有时候很多小伙伴问我，我是该怎么学一个我没接触过的内容。我的个人经验非常建议，先不要学太多理论性的内容，而是尝试实际操作下，把要学的内容做一些 Demo 案例出来。这有点像你买了个自行车是先拆了学学怎么个原理，还是先骑几圈呢？哪怕摔了跟头，但那都是必须经历后留下的经验。

同样我也知道很多人看了设计模式收获不大，这主要新人对没有案例或者案例不贴近实际场景没有学习方向导致。太空、太虚、太玄，让人没有抓手！

所以我开始编写以实际案例为着手的方式，讲解设计模式的文章，帮助大家成长的同时也让我自己有所沉淀！

二、开发环境

  1. JDK 1.8
  2. Idea + Maven
  3. 涉及工程三个，可以通过关注 公众号 ：bugstack 虫洞栈，回复 源码下载 获取(打开获取的链接，找到序号 18)
工程 描述
itstack-demo-design-4-00 场景模拟工程，模拟在线考试题库抽提打乱顺序
itstack-demo-design-4-01 使用一坨代码实现业务需求，也是对 ifelse 的使用
itstack-demo-design-4-02 通过设计模式优化改造代码，产生对比性从而学习

三、原型模式介绍

原型模式主要解决的问题就是创建重复对象，而这部分 对象 内容本身比较复杂，生成过程可能从库或者 RPC 接口中获取数据的耗时较长，因此采用克隆的方式节省时间。

其实这种场景经常出现在我们的身边，只不过很少用到自己的开发中，就像；

  1. 你经常Ctrl+C、Ctrl+V，复制粘贴代码。
  2. Java 多数类中提供的 API 方法；Object clone()。
  3. 细胞的有丝分裂。

类似以上的场景并不少，但如果让你去思考平时的代码开发中，有用到这样的设计模式吗？确实不那么容易找到，甚至有时候是忽略了这个设计模式的方式。在没有阅读下文之前，也可以思考下哪些场景可以用到。

四、案例场景模拟

每个人都经历过考试，从纸制版到上机答题，大大小小也有几百场。而以前坐在教室里答题身边的人都是一套试卷，考试的时候还能偷摸或者别人给发信息抄一抄答案。

但从一部分可以上机考试的内容开始，在保证大家的公平性一样的题目下，开始出现试题混排更有做的好的答案选项也混排。这样大大的增加了抄的成本，也更好的做到了考试的公平性。

但如果这个公平性的考试需求交给你来完成，你会怎么做？

因为需要实现一个上机考试抽题的服务，因此在这里建造一个题库题目的场景类信息，用于创建；选择题 、 问答题。

1. 场景模拟工程

itstack-demo-design-4-00
└── src
    └── main
        └── java
            └── org.itstack.demo.design
                ├── AnswerQuestion.java
                └── ChoiceQuestion.java
  • 在这里模拟了两个试卷题目的类；ChoiceQuestion(选择题 )、AnswerQuestion( 问答题)。如果是实际的业务场景开发中，会有更多的题目类型，可以回忆一下你的高考试卷。

2. 场景简述

2.1 选择题

public class ChoiceQuestion {

    private String name;                 // 题目
    private Map<String, String> option;  // 选项；A、B、C、D
    private String key;                  // 答案；B

    public ChoiceQuestion() {}

    public ChoiceQuestion(String name, Map<String, String> option, String key) {
        this.name = name;
        this.option = option;
        this.key = key;
    }

    // ...get/set
}

2.2 问答题

public class AnswerQuestion {

    private String name;  // 问题
    private String key;   // 答案

    public AnswerQuestion() {}

    public AnswerQuestion(String name, String key) {
        this.name = name;
        this.key = key;
    }

    // ...get/set
}
  • 以上两个类就是我们场景中需要的物料内容，相对来说比较简单。如果你在测试的时候想扩充学习，可以继续添加一些其他物料 ( 题目类型)。

五、用一坨坨代码实现

今天的实现方式没有 ifelse 了，但是没有一个类解决不了的业务，只要你胆大！

在以下的例子中我们会按照每一个用户创建试卷的题目，并返回给调用方。

1. 工程结构

itstack-demo-design-4-01
└── src
    └── main
        └── java
            └── org.itstack.demo.design
                └── QuestionBankController.java
  • 一个类几千行的代码你是否见过，嚯？那今天就再让你见识一下有这样潜质的类！

2. 一把梭实现需求

public class QuestionBankController {public String createPaper(String candidate, String number) {List<ChoiceQuestion> choiceQuestionList = new ArrayList<ChoiceQuestion>();
        List<AnswerQuestion> answerQuestionList = new ArrayList<AnswerQuestion>();

        Map<String, String> map01 = new HashMap<String, String>();
        map01.put("A", "JAVA2 EE");
        map01.put("B", "JAVA2 Card");
        map01.put("C", "JAVA2 ME");
        map01.put("D", "JAVA2 HE");
        map01.put("E", "JAVA2 SE");

        Map<String, String> map02 = new HashMap<String, String>();
        map02.put("A", "JAVA 程序的 main 方法必须写在类里面");
        map02.put("B", "JAVA 程序中可以有多个 main 方法");
        map02.put("C", "JAVA 程序中类名必须与文件名一样");
        map02.put("D", "JAVA 程序的 main 方法中如果只有一条语句，可以不用 {}(大括号) 括起来");

        Map<String, String> map03 = new HashMap<String, String>();
        map03.put("A", "变量由字母、下划线、数字、$ 符号随意组成；");
        map03.put("B", "变量不能以数字作为开头；");
        map03.put("C", "A 和 a 在 java 中是同一个变量；");
        map03.put("D", "不同类型的变量，可以起相同的名字；");

        Map<String, String> map04 = new HashMap<String, String>();
        map04.put("A", "STRING");
        map04.put("B", "x3x;");
        map04.put("C", "void");
        map04.put("D", "de$f");

        Map<String, String> map05 = new HashMap<String, String>();
        map05.put("A", "31");
        map05.put("B", "0");
        map05.put("C", "1");
        map05.put("D", "2");

        choiceQuestionList.add(new ChoiceQuestion("JAVA 所定义的版本中不包括", map01, "D"));
        choiceQuestionList.add(new ChoiceQuestion("下列说法正确的是", map02, "A"));
        choiceQuestionList.add(new ChoiceQuestion("变量命名规范说法正确的是", map03, "B"));
        choiceQuestionList.add(new ChoiceQuestion("以下 () 不是合法的标识符", map04, "C"));
        choiceQuestionList.add(new ChoiceQuestion("表达式(11+3*8)/4%3 的值是", map05, "D"));
        answerQuestionList.add(new AnswerQuestion("小红马和小黑马生的小马几条腿", "4 条腿"));
        answerQuestionList.add(new AnswerQuestion("铁棒打头疼还是木棒打头疼", "头最疼"));
        answerQuestionList.add(new AnswerQuestion("什么床不能睡觉", "牙床"));
        answerQuestionList.add(new AnswerQuestion("为什么好马不吃回头草", "后面的草没了"));

        // 输出结果
        StringBuilder detail = new StringBuilder("考生：" + candidate + "\r\n" +
                "考号：" + number + "\r\n" +
                "--------------------------------------------\r\n" +
                "一、选择题" + "\r\n\n");

        for (int idx = 0; idx < choiceQuestionList.size(); idx++) {detail.append("第").append(idx + 1).append("题：").append(choiceQuestionList.get(idx).getName()).append("\r\n");
            Map<String, String> option = choiceQuestionList.get(idx).getOption();
            for (String key : option.keySet()) {detail.append(key).append("：").append(option.get(key)).append("\r\n");
                ;
            }
            detail.append("答案：").append(choiceQuestionList.get(idx).getKey()).append("\r\n\n");
        }

        detail.append("二、问答题" + "\r\n\n");

        for (int idx = 0; idx < answerQuestionList.size(); idx++) {detail.append("第").append(idx + 1).append("题：").append(answerQuestionList.get(idx).getName()).append("\r\n");
            detail.append("答案：").append(answerQuestionList.get(idx).getKey()).append("\r\n\n");
        }

        return detail.toString();}

}
  • 这样的代码往往都非常易于理解，要什么程序就给什么代码，不面向对象，只面向过程。不考虑扩展性，能用就行。
  • 以上的代码主要就三部分内容；首先创建选择题和问答题到集合中、定义详情字符串包装结果、返回结果内容。
  • 但以上的代码有一个没有实现的地方就是不能乱序，所有人的试卷顺序都是一样的。如果需要加乱序也是可以的，但复杂度又会增加。这里不展示具体过多实现，只为后文对比重构。

3. 测试验证

接下来我们通过 junit 单元测试的方式验证接口服务，强调日常编写好单测可以更好的提高系统的健壮度。

编写测试类：

@Test
public void test_QuestionBankController() {QuestionBankController questionBankController = new QuestionBankController();
    System.out.println(questionBankController.createPaper("花花", "1000001921032"));
    System.out.println(questionBankController.createPaper("豆豆", "1000001921051"));
    System.out.println(questionBankController.createPaper("大宝", "1000001921987"));
}

结果：

考生：花花
考号：1000001921032
--------------------------------------------
一、选择题

第 1 题：JAVA 所定义的版本中不包括
A：JAVA2 EE
B：JAVA2 Card
C：JAVA2 ME
D：JAVA2 HE
E：JAVA2 SE
答案：D

第 2 题：下列说法正确的是
A：JAVA 程序的 main 方法必须写在类里面
B：JAVA 程序中可以有多个 main 方法
C：JAVA 程序中类名必须与文件名一样
D：JAVA 程序的 main 方法中如果只有一条语句，可以不用 {}(大括号) 括起来
答案：A

第 3 题：变量命名规范说法正确的是
A：变量由字母、下划线、数字、$ 符号随意组成；B：变量不能以数字作为开头；C：A 和 a 在 java 中是同一个变量；D：不同类型的变量，可以起相同的名字；答案：B

第 4 题：以下 () 不是合法的标识符
A：STRING
B：x3x;
C：void
D：de$f
答案：C

第 5 题：表达式(11+3*8)/4%3 的值是
A：31
B：0
C：1
D：2
答案：D

二、问答题

第 1 题：小红马和小黑马生的小马几条腿
答案：4 条腿

第 2 题：铁棒打头疼还是木棒打头疼
答案：头最疼

第 3 题：什么床不能睡觉
答案：牙床

第 4 题：为什么好马不吃回头草
答案：后面的草没了


考生：豆豆
考号：1000001921051
--------------------------------------------
一、选择题

第 1 题：JAVA 所定义的版本中不包括
A：JAVA2 EE
B：JAVA2 Card
C：JAVA2 ME
D：JAVA2 HE
E：JAVA2 SE
答案：D

第 2 题：下列说法正确的是
A：JAVA 程序的 main 方法必须写在类里面
B：JAVA 程序中可以有多个 main 方法
C：JAVA 程序中类名必须与文件名一样
D：JAVA 程序的 main 方法中如果只有一条语句，可以不用 {}(大括号) 括起来
答案：A

第 3 题：变量命名规范说法正确的是
A：变量由字母、下划线、数字、$ 符号随意组成；B：变量不能以数字作为开头；C：A 和 a 在 java 中是同一个变量；D：不同类型的变量，可以起相同的名字；答案：B

第 4 题：以下 () 不是合法的标识符
A：STRING
B：x3x;
C：void
D：de$f
答案：C

第 5 题：表达式(11+3*8)/4%3 的值是
A：31
B：0
C：1
D：2
答案：D

二、问答题

第 1 题：小红马和小黑马生的小马几条腿
答案：4 条腿

第 2 题：铁棒打头疼还是木棒打头疼
答案：头最疼

第 3 题：什么床不能睡觉
答案：牙床

第 4 题：为什么好马不吃回头草
答案：后面的草没了


考生：大宝
考号：1000001921987
--------------------------------------------
一、选择题

第 1 题：JAVA 所定义的版本中不包括
A：JAVA2 EE
B：JAVA2 Card
C：JAVA2 ME
D：JAVA2 HE
E：JAVA2 SE
答案：D

第 2 题：下列说法正确的是
A：JAVA 程序的 main 方法必须写在类里面
B：JAVA 程序中可以有多个 main 方法
C：JAVA 程序中类名必须与文件名一样
D：JAVA 程序的 main 方法中如果只有一条语句，可以不用 {}(大括号) 括起来
答案：A

第 3 题：变量命名规范说法正确的是
A：变量由字母、下划线、数字、$ 符号随意组成；B：变量不能以数字作为开头；C：A 和 a 在 java 中是同一个变量；D：不同类型的变量，可以起相同的名字；答案：B

第 4 题：以下 () 不是合法的标识符
A：STRING
B：x3x;
C：void
D：de$f
答案：C

第 5 题：表达式(11+3*8)/4%3 的值是
A：31
B：0
C：1
D：2
答案：D

二、问答题

第 1 题：小红马和小黑马生的小马几条腿
答案：4 条腿

第 2 题：铁棒打头疼还是木棒打头疼
答案：头最疼

第 3 题：什么床不能睡觉
答案：牙床

第 4 题：为什么好马不吃回头草
答案：后面的草没了

Process finished with exit code 0
  • 以上呢就是三位考试的试卷；花花 、 豆豆 、 大宝，每个人的试卷内容是一样的这没问题，但是三个人的题目以及选项顺序都是一样，就没有达到我们说希望的乱序要求。
  • 而且以上这样的代码非常难扩展，随着题目的不断的增加以及乱序功能的补充，都会让这段代码变得越来越混乱。

六、原型模式重构代码

接下来使用原型模式来进行代码优化，也算是一次很小的重构。

原型模式主要解决的问题就是创建大量重复的类，而我们模拟的场景就需要给不同的用户都创建相同的试卷，但这些试卷的题目不便于每次都从库中获取，甚至有时候需要从远程的 RPC 中获取。这样都是非常耗时的，而且随着创建对象的增多将严重影响效率。

在原型模式中所需要的非常重要的手段就是克隆，在需要用到克隆的类中都需要实现 implements Cloneable 接口。

1. 工程结构

itstack-demo-design-4-02
└── src
    ├── main
    │   └── java
    │       └── org.itstack.demo.design
    │           ├── util
    │           │   ├── Topic.java
    │           │   └── TopicRandomUtil.java
    │           ├── QuestionBank.java
    │           └── QuestionBankController.java 
    └── test
         └── java
             └── org.itstack.demo.design.test
                 └── ApiTest.java

原型模式模型结构

  • 工程中包括了核心的题库类QuestionBank，题库中主要负责将各个的题目进行组装最终输出试卷。
  • 针对每一个试卷都会使用克隆的方式进行复制，复制完成后将试卷中题目以及每个题目的答案进行乱序处理。这里提供了工具包；TopicRandomUtil

2. 代码实现

2.1 题目选项乱序操作工具包

/**
 * 乱序 Map 元素，记录对应答案 key
 * @param option 题目
 * @param key    答案
 * @return Topic 乱序后 {A=c., B=d., C=a., D=b.}
 */
static public Topic random(Map<String, String> option, String key) {Set<String> keySet = option.keySet();
    ArrayList<String> keyList = new ArrayList<String>(keySet);
    Collections.shuffle(keyList);
    HashMap<String, String> optionNew = new HashMap<String, String>();
    int idx = 0;
    String keyNew = "";
    for (String next : keySet) {String randomKey = keyList.get(idx++);
        if (key.equals(next)) {keyNew = randomKey;}
        optionNew.put(randomKey, option.get(next));
    }
    return new Topic(optionNew, keyNew);
}
  • 可能你还记得上文里我们提供了 Map 存储题目选项，同时 key 的属性存放答案。如果忘记可以往上翻翻
  • 这个这个工具类的操作就是将原有 Map 中的选型乱序操作，也就是 A 的选项内容给 B ， B 的可能给 C ，同时记录正确答案在处理后的位置信息。

2.2 克隆对象处理类

public class QuestionBank implements Cloneable {

    private String candidate; // 考生
    private String number;    // 考号

    private ArrayList<ChoiceQuestion> choiceQuestionList = new ArrayList<ChoiceQuestion>();
    private ArrayList<AnswerQuestion> answerQuestionList = new ArrayList<AnswerQuestion>();

    public QuestionBank append(ChoiceQuestion choiceQuestion) {choiceQuestionList.add(choiceQuestion);
        return this;
    }

    public QuestionBank append(AnswerQuestion answerQuestion) {answerQuestionList.add(answerQuestion);
        return this;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {QuestionBank questionBank = (QuestionBank) super.clone();
        questionBank.choiceQuestionList = (ArrayList<ChoiceQuestion>) choiceQuestionList.clone();
        questionBank.answerQuestionList = (ArrayList<AnswerQuestion>) answerQuestionList.clone();

        // 题目乱序
        Collections.shuffle(questionBank.choiceQuestionList);
        Collections.shuffle(questionBank.answerQuestionList);
        // 答案乱序
        ArrayList<ChoiceQuestion> choiceQuestionList = questionBank.choiceQuestionList;
        for (ChoiceQuestion question : choiceQuestionList) {Topic random = TopicRandomUtil.random(question.getOption(), question.getKey());
            question.setOption(random.getOption());
            question.setKey(random.getKey());
        }
        return questionBank;
    }

    public void setCandidate(String candidate) {this.candidate = candidate;}

    public void setNumber(String number) {this.number = number;}

    @Override
    public String toString() {

        StringBuilder detail = new StringBuilder("考生：" + candidate + "\r\n" +
                "考号：" + number + "\r\n" +
                "--------------------------------------------\r\n" +
                "一、选择题" + "\r\n\n");

        for (int idx = 0; idx < choiceQuestionList.size(); idx++) {detail.append("第").append(idx + 1).append("题：").append(choiceQuestionList.get(idx).getName()).append("\r\n");
            Map<String, String> option = choiceQuestionList.get(idx).getOption();
            for (String key : option.keySet()) {detail.append(key).append("：").append(option.get(key)).append("\r\n");;
            }
            detail.append("答案：").append(choiceQuestionList.get(idx).getKey()).append("\r\n\n");
        }

        detail.append("二、问答题" + "\r\n\n");

        for (int idx = 0; idx < answerQuestionList.size(); idx++) {detail.append("第").append(idx + 1).append("题：").append(answerQuestionList.get(idx).getName()).append("\r\n");
            detail.append("答案：").append(answerQuestionList.get(idx).getKey()).append("\r\n\n");
        }

        return detail.toString();}

}

这里的主要操作内容有三个，分别是；

  • 两个append()，对各项题目的添加，有点像我们在建造者模式中使用的方式，添加装修物料。
  • clone() ，这里的核心操作就是对对象的复制，这里的复制不只是包括了本身，同时对两个集合也做了复制。只有这样的拷贝才能确保在操作克隆对象的时候不影响原对象。
  • 乱序操作，在 list 集合中有一个方法，Collections.shuffle，可以将原有集合的顺序打乱，输出一个新的顺序。在这里我们使用此方法对题目进行乱序操作。

2.4 初始化试卷数据

public class QuestionBankController {private QuestionBank questionBank = new QuestionBank();

    public QuestionBankController() {Map<String, String> map01 = new HashMap<String, String>();
        map01.put("A", "JAVA2 EE");
        map01.put("B", "JAVA2 Card");
        map01.put("C", "JAVA2 ME");
        map01.put("D", "JAVA2 HE");
        map01.put("E", "JAVA2 SE");

        Map<String, String> map02 = new HashMap<String, String>();
        map02.put("A", "JAVA 程序的 main 方法必须写在类里面");
        map02.put("B", "JAVA 程序中可以有多个 main 方法");
        map02.put("C", "JAVA 程序中类名必须与文件名一样");
        map02.put("D", "JAVA 程序的 main 方法中如果只有一条语句，可以不用 {}(大括号) 括起来");

        Map<String, String> map03 = new HashMap<String, String>();
        map03.put("A", "变量由字母、下划线、数字、$ 符号随意组成；");
        map03.put("B", "变量不能以数字作为开头；");
        map03.put("C", "A 和 a 在 java 中是同一个变量；");
        map03.put("D", "不同类型的变量，可以起相同的名字；");

        Map<String, String> map04 = new HashMap<String, String>();
        map04.put("A", "STRING");
        map04.put("B", "x3x;");
        map04.put("C", "void");
        map04.put("D", "de$f");

        Map<String, String> map05 = new HashMap<String, String>();
        map05.put("A", "31");
        map05.put("B", "0");
        map05.put("C", "1");
        map05.put("D", "2");
        
        questionBank.append(new ChoiceQuestion("JAVA 所定义的版本中不包括", map01, "D"))
                .append(new ChoiceQuestion("下列说法正确的是", map02, "A"))
                .append(new ChoiceQuestion("变量命名规范说法正确的是", map03, "B"))
                .append(new ChoiceQuestion("以下 () 不是合法的标识符",map04, "C"))
                .append(new ChoiceQuestion("表达式(11+3*8)/4%3 的值是", map05, "D"))
                .append(new AnswerQuestion("小红马和小黑马生的小马几条腿", "4 条腿"))
                .append(new AnswerQuestion("铁棒打头疼还是木棒打头疼", "头最疼"))
                .append(new AnswerQuestion("什么床不能睡觉", "牙床"))
                .append(new AnswerQuestion("为什么好马不吃回头草", "后面的草没了"));
    }

    public String createPaper(String candidate, String number) throws CloneNotSupportedException {QuestionBank questionBankClone = (QuestionBank) questionBank.clone();
        questionBankClone.setCandidate(candidate);
        questionBankClone.setNumber(number);
        return questionBankClone.toString();}

}
  • 这个类的内容就比较简单了，主要提供对试卷内容的模式初始化操作 ( 所有考生试卷一样，题目顺序不一致)。
  • 以及对外部提供创建试卷的方法，在创建的过程中使用的是克隆的方式；(QuestionBank) questionBank.clone();，并最终返回试卷信息。

3. 测试验证

编写测试类：

@Test
public void test_QuestionBank() throws CloneNotSupportedException {QuestionBankController questionBankController = new QuestionBankController();
    System.out.println(questionBankController.createPaper("花花", "1000001921032"));
    System.out.println(questionBankController.createPaper("豆豆", "1000001921051"));
    System.out.println(questionBankController.createPaper("大宝", "1000001921987"));
}

结果：

考生：花花
考号：1000001921032
--------------------------------------------
一、选择题

第 1 题：JAVA 所定义的版本中不包括
A：JAVA2 Card
B：JAVA2 HE
C：JAVA2 EE
D：JAVA2 ME
E：JAVA2 SE
答案：B

第 2 题：表达式(11+3*8)/4%3 的值是
A：1
B：0
C：31
D：2
答案：D

第 3 题：以下 () 不是合法的标识符
A：void
B：de$f
C：STRING
D：x3x;
答案：A

第 4 题：下列说法正确的是
A：JAVA 程序的 main 方法中如果只有一条语句，可以不用 {}(大括号) 括起来
B：JAVA 程序中可以有多个 main 方法
C：JAVA 程序的 main 方法必须写在类里面
D：JAVA 程序中类名必须与文件名一样
答案：C

第 5 题：变量命名规范说法正确的是
A：变量由字母、下划线、数字、$ 符号随意组成；B：A 和 a 在 java 中是同一个变量；C：不同类型的变量，可以起相同的名字；D：变量不能以数字作为开头；答案：D

二、问答题

第 1 题：小红马和小黑马生的小马几条腿
答案：4 条腿

第 2 题：什么床不能睡觉
答案：牙床

第 3 题：铁棒打头疼还是木棒打头疼
答案：头最疼

第 4 题：为什么好马不吃回头草
答案：后面的草没了


考生：豆豆
考号：1000001921051
--------------------------------------------
一、选择题

第 1 题：下列说法正确的是
A：JAVA 程序中可以有多个 main 方法
B：JAVA 程序的 main 方法必须写在类里面
C：JAVA 程序的 main 方法中如果只有一条语句，可以不用 {}(大括号) 括起来
D：JAVA 程序中类名必须与文件名一样
答案：B

第 2 题：表达式(11+3*8)/4%3 的值是
A：2
B：1
C：31
D：0
答案：A

第 3 题：以下 () 不是合法的标识符
A：void
B：de$f
C：x3x;
D：STRING
答案：A

第 4 题：JAVA 所定义的版本中不包括
A：JAVA2 Card
B：JAVA2 HE
C：JAVA2 ME
D：JAVA2 EE
E：JAVA2 SE
答案：B

第 5 题：变量命名规范说法正确的是
A：变量不能以数字作为开头；B：A 和 a 在 java 中是同一个变量；C：不同类型的变量，可以起相同的名字；D：变量由字母、下划线、数字、$ 符号随意组成；答案：A

二、问答题

第 1 题：什么床不能睡觉
答案：牙床

第 2 题：铁棒打头疼还是木棒打头疼
答案：头最疼

第 3 题：为什么好马不吃回头草
答案：后面的草没了

第 4 题：小红马和小黑马生的小马几条腿
答案：4 条腿


考生：大宝
考号：1000001921987
--------------------------------------------
一、选择题

第 1 题：以下 () 不是合法的标识符
A：x3x;
B：de$f
C：void
D：STRING
答案：C

第 2 题：表达式(11+3*8)/4%3 的值是
A：31
B：0
C：2
D：1
答案：C

第 3 题：变量命名规范说法正确的是
A：不同类型的变量，可以起相同的名字；B：变量由字母、下划线、数字、$ 符号随意组成；C：变量不能以数字作为开头；D：A 和 a 在 java 中是同一个变量；答案：C

第 4 题：下列说法正确的是
A：JAVA 程序的 main 方法中如果只有一条语句，可以不用 {}(大括号) 括起来
B：JAVA 程序的 main 方法必须写在类里面
C：JAVA 程序中类名必须与文件名一样
D：JAVA 程序中可以有多个 main 方法
答案：B

第 5 题：JAVA 所定义的版本中不包括
A：JAVA2 EE
B：JAVA2 Card
C：JAVA2 HE
D：JAVA2 SE
E：JAVA2 ME
答案：C

二、问答题

第 1 题：为什么好马不吃回头草
答案：后面的草没了

第 2 题：小红马和小黑马生的小马几条腿
答案：4 条腿

第 3 题：什么床不能睡觉
答案：牙床

第 4 题：铁棒打头疼还是木棒打头疼
答案：头最疼

Process finished with exit code 0

从以上的输出结果可以看到，每个人的题目和答案都是差异化的乱序的，如下图比对结果； – 花花、豆豆、大宝，每个人的试卷都存在着题目和选项的混乱排序

七、总结

  • 以上的实际场景模拟了原型模式在开发中重构的作用，但是原型模式的使用频率确实不是很高。如果有一些特殊场景需要使用到，也可以按照此设计模式进行优化。
  • 另外原型设计模式的优点包括；便于通过克隆方式创建复杂对象、也可以避免重复做初始化操作、不需要与类中所属的其他类耦合等。但也有一些缺点如果对象中包括了循环引用的克隆，以及类中深度使用对象的克隆，都会使此模式变得异常麻烦。
  • 终究设计模式是一整套的思想，在不同的场景合理的运用可以提升整体的架构的质量。永远不要想着去硬凑设计模式，否则将会引起过渡设计，以及在承接业务反复变化的需求时造成浪费的开发和维护成本。
  • 初期是代码的优化，中期是设计模式的使用，后期是把控全局服务的搭建。不断的加强自己对全局能力的把控，也加深自己对细节的处理。可上可下才是一个程序员最佳处理方式，选取做合适的才是最好的选择。

八、推荐阅读

  • Java 开发架构篇：初识领域驱动设计 DDD 落地
  • Java 开发架构篇：DDD 模型领域层决策规则树服务设计
  • Java 开发架构篇：领域驱动设计架构基于 SpringCloud 搭建微服务
  • 源码分析(面试常问题目) | Mybatis 接口没有实现类为什么可以执行增删改查
  • 讲道理，只要你是一个爱折腾的程序员，毕业找工作真的不需要再花钱培训！
退出移动版