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

时间  2020-05-30
标签 java 设计 模式 实战 原型 栏目 Java 繁體版
原文   原文链接

摄图网_1590679504.png

做者：小傅哥
博客：https://bugstack.cnhtml

沉淀、分享、成长，让本身和他人都能有所收获！😄

1、前言

老板你加钱个人代码能飞java

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

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

不管作哪行那业你都喜欢，每每来自从中持续不断都获取成就感。就开发编程而言由于你的一行代码影响到了千千万万的人、由于你的一行代码整个系统更加稳定、由于你的一行代码扛过了全部秒杀等等，这样一行行的代码都是你日积月累学习到的经验。那若是你也想成为这样有成就感的程序员就须要不断的学习，不断的用更多的技能知识把本身编写的代码运用到更核心的系统。编程

方向不对努力白费设计模式

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

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

因此我开始编写以实际案例为着手的方式，讲解设计模式的文章，帮助你们成长的同时也让我本身有所沉淀！dom

2、开发环境

  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 经过设计模式优化改造代码，产生对比性从而学习

3、原型模式介绍

原型模式，图片来自 refactoringguru.cn

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

其实这种场景常常出如今咱们的身边，只不过不多用到本身的开发中，就像；

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

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

4、案例场景模拟

场景模拟；考试试卷

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

但从一部分能够上机考试的内容开始，在保证你们的公平性同样的题目下，开始出现试题混排更有作的好的答案选项也混排。这样大大的增长了抄的成本，也更好的作到了考试的公平性。

但若是这个公平性的考试需求交给你来完成，你会怎么作？

由于须要实现一个上机考试抽题的服务，所以在这里建造一个题库题目的场景类信息，用于建立；选择题、问答题。

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
}
  • 以上两个类就是咱们场景中须要的物料内容，相对来讲比较简单。若是你在测试的时候想扩充学习，能够继续添加一些其余物料(题目类型)。

5、用一坨坨代码实现

今天的实现方式没有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" +
                "1、选择题" + "\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("2、问答题" + "\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、选择题

第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

2、问答题

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

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

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

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


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

第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

2、问答题

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

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

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

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


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

第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

2、问答题

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

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

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

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

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

6、原型模式重构代码

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

原型模式主要解决的问题就是建立大量重复的类，而咱们模拟的场景就须要给不一样的用户都建立相同的试卷，但这些试卷的题目不便于每次都从库中获取，甚至有时候须要从远程的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" +
                "1、选择题" + "\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("2、问答题" + "\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、选择题

第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

2、问答题

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

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

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

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


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

第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

2、问答题

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

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

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

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


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

第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

2、问答题

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

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

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

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

Process finished with exit code 0

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

原型模式，乱序题目比对结果

7、总结

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

8、推荐阅读

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程