vieyahn2017
commented
2 years ago 试题来自
设计模式 考试题+答案 https://blog.csdn.net/qq_41371349/article/details/104839456
Closed vieyahn2017 closed 3 months ago
vieyahn2017
commented
2 years ago 试题来自
设计模式 考试题+答案 https://blog.csdn.net/qq_41371349/article/details/104839456
vieyahn2017
commented
2 years ago questions.txt
设计模式一般用来解决什么样的问题()
A.同一问题的不同表相
B.不同问题的同一表相
C.不同问题的不同表相
D.以上都不是
A
设计模式的两大主题是()
A.系统的维护与开发
B.对象组合与类的继承
C.系统架构与系统开发
D.系统复用与系统扩展
D
下列关于简单工厂模式与工厂方法模式表述错误的是（）
A. 两者都 满足开闭原则：简单工厂以if else 方式创建对象，增加需求看看 时候会修改源代码
B. 简单工厂对具体产品的创建类别和创建时机的判断是混合在一起的，这点在工厂方法模式中已经克服
C. 不能形成简单工厂的继承结构
D. 在工厂方法模式中，对于存在继承等级结构的产品树，产品的创建是通过相应等级结构的工厂创建的。
A
设计模式一般被分为三大类，其中行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配，下列模式中属于行为模式的是（）
A. 抽象工厂（Abstract Factory)
B. 适配器（Adapter）
C. 观察者（Observer)
D. 职责链（Chain of Responsibility）
CD
设计模式中关于结构型模式，以下说法正确的是
A. 结构型模式可以在不破坏类封装性的基础上，实现新的功能
B. 结构型模式主要用于创建一组对象
C. 结构型模式可以创建一组类的统一访问接口
D. 结构型模式可以在不破坏类封装性的基础上，使得类可以通不曾估计到的系统进行交互
ACD
面向对象设计的基本原则中的开闭原则指出软件要对扩展开放，对修改关闭。违反开闭原则可能造成的坏味道有
A. 基本类型偏执(Primitive Obsession)
B. 散弹式修改(Shotgun Surgery)
C. 过长参数列表(Long Parameter List)
D. 发散式变化(Divergent Change)
BD
敏感对象发送出信任域前应该先加密然后再签名。
错
当实现Socket通信模块时，若需要保证传输数据的安全性，可以考虑使用java.net.Socket来建立安全的网络传输通道。
错
对于以下代码实现关于存在的安全风险，下列说法正确的是（）
class DirList{
public static void main(String[] args) throws Exception{
String dir = Systeim.getProperty( 'dir' );
Runtime rt = runtime.getRuntime();
Process proc = rt.exec /C dir '+ dir);
int result = proc.waitFor();
if (result != 0){
System.out.printIn( 'process error: '+ result);
}
InputStream in = (result==0)? proc.getInputStream();
proc.getErrorStream();
intc;
while((c = in.read()!=-1){
System.out.print((char) c);
}
}
}
A、输出敏感信息
B、流未正确释放
C、代码存在命令注入风险
D、进程阻塞在输入输出流上
BCD
parse_question_to_json.py
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
默认导入以下6行式的题目
关于可靠性和可用性间的关系，下列哪种说法是正确的？
A. 可靠性等同于可用性
B. 高可用性除了要求具有高可靠性外，还必须具有良好的可维修性
C. 可靠性和可用性是两个概念，两者间没有关系
D. 可用性只与可靠性相关，与可维修性无关
B
下面哪些设计是符合权限最小化要求的？（）
A. 一个帐号只能拥有该角色必需的权限，不分配不必要的权限。
B. 权限划分的粒度尽可能最小化，帐号权限应基于“need-to-know”和“case-by-case”的原则。
C. 为保证有足够权限读取到数据，连接Web服务数据库应该使用Administrator帐号。
D. 审计日志只有管理员或日志审计员有权限读取，普通用户无法访问读取。
ABD
选项ABCD支持 空白 . , 、 ， 【分别是 空白 英文点号，英文逗号，中文顿号，中文逗号 】
"""
import sys
import time
import datetime
import json
import re
import codecs
reload(sys)
sys.setdefaultencoding('utf8')
class Question:
pass
file = open("questions.txt", mode='r')
# lines = file.readlines()
txt = file.read()
questions = re.split("\n\n+", txt)
def make_question(content_lines):
# 先排空
if not content_lines:
return {}
answer = content_lines[-1]
if answer == "对" or answer == "错":
subjectType = 3 # 判断题
title = "\r\n".join(content_lines[:-1])
optionList = []
return {"subjectTitle": title, "subjectType": subjectType, "answer": answer, "optionList": optionList, "subjectId": ""}
answer_line = -1
option_separator = " "
# 查找选项的第一行，之前的行作为title
for line in content_lines:
answer_line += 1
if line.startswith("A、"):
option_separator = "、"
break
if line.startswith("A."):
option_separator = "."
break
if line.startswith("A,"):
option_separator = ","
break
if line.startswith("A，"):
option_separator = "，"
break
if line.startswith("A "): # 单独的A加空格，再往下找B，才能准确
if content_lines[answer_line].startswith("B"):
break
answer = content_lines[-1]
options = content_lines[answer_line:-1]
optionList = []
for line2 in options:
# split带参数1，分隔成两个
# optionId = line2.split(option_separator, 1)[0] # 没必要这么复杂，直接取第一个字符即可
optionId = line2[0]
optionList.append({"optionId": optionId, "optionTitle": line2})
if answer_line == 1:
title = content_lines[0]
else:
title = "\r\n".join(content_lines[:answer_line])
# if answer == "对" or answer == "错":
# subjectType = 3 # 判断题 的逻辑单独提到前面去了
if len(answer) == 1:
subjectType = 1 # 单选题
else:
subjectType = 2 # 多选题
answer = "&".join(answer)
# return title, optionList, answer, subjectType
return {"subjectTitle": title, "subjectType": subjectType, "answer": answer, "optionList": optionList, "subjectId": ""}
outputs = []
outputs.append("[")
for question in questions:
if question == "":
continue
items = question.split("\n")
try:
json_item = make_question(items)
if json_item:
item_json = json.dumps(json_item, sort_keys=True, indent=4, ensure_ascii=False)
print(item_json)
outputs.append(item_json + ",")
except:
print(">>> error occur\n" + questions)
pass
outputs.append("]")
#strtime = (datetime.datetime.now() - datetime.timedelta(hours=1)).strftime("%Y%m%d%H%M%S")
strtime = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
file2name = "{}-exam.json".format(strtime)
# 如果要指定utf8编码
# file2 = open(file2name, mode='w', encoding='utf-8') # python3
# file2 = codecs.open(file2name, 'w', 'utf-8') # python2.7
file2 = open(file2name, mode='w')
file2.write("\n".join(outputs))
# 备份questions.txt
file1 = open("{}-questions.txt".format(strtime), mode='w')
file1.write(txt)
执行 python parse_question_to_json.py
vieyahn2017
commented
2 years ago 生成 20210907_192109-exam.json
[
{
"answer": "A",
"optionList": [
{
"optionId": "A",
"optionTitle": "A.同一问题的不同表相"
},
{
"optionId": "B",
"optionTitle": "B.不同问题的同一表相"
},
{
"optionId": "C",
"optionTitle": "C.不同问题的不同表相"
},
{
"optionId": "D",
"optionTitle": "D.以上都不是"
}
],
"subjectId": "",
"subjectTitle": "设计模式一般用来解决什么样的问题()",
"subjectType": 1
},
{
"answer": "D",
"optionList": [
{
"optionId": "A",
"optionTitle": "A.系统的维护与开发"
},
{
"optionId": "B",
"optionTitle": "B.对象组合与类的继承"
},
{
"optionId": "C",
"optionTitle": "C.系统架构与系统开发"
},
{
"optionId": "D",
"optionTitle": "D.系统复用与系统扩展"
}
],
"subjectId": "",
"subjectTitle": "设计模式的两大主题是()",
"subjectType": 1
},
{
"answer": "A",
"optionList": [
{
"optionId": "A",
"optionTitle": "A. 两者都 满足开闭原则：简单工厂以if else 方式创建对象，增加需求看看 时候会修改源代码 "
},
{
"optionId": "B",
"optionTitle": "B. 简单工厂对具体产品的创建类别和创建时机的判断是混合在一起的，这点在工厂方法模式中已经克服"
},
{
"optionId": "C",
"optionTitle": "C. 不能形成简单工厂的继承结构"
},
{
"optionId": "D",
"optionTitle": "D. 在工厂方法模式中，对于存在继承等级结构的产品树，产品的创建是通过相应等级结构的工厂创建的。"
}
],
"subjectId": "",
"subjectTitle": "下列关于简单工厂模式与工厂方法模式表述错误的是（）",
"subjectType": 1
},
{
"answer": "C&D",
"optionList": [
{
"optionId": "A",
"optionTitle": "A. 抽象工厂（Abstract Factory)"
},
{
"optionId": "B",
"optionTitle": "B. 适配器（Adapter）"
},
{
"optionId": "C",
"optionTitle": "C. 观察者（Observer)"
},
{
"optionId": "D",
"optionTitle": "D. 职责链（Chain of Responsibility）"
}
],
"subjectId": "",
"subjectTitle": "设计模式一般被分为三大类，其中行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配，下列模式中属于行为模式的是（）",
"subjectType": 2
},
{
"answer": "A&C&D",
"optionList": [
{
"optionId": "A",
"optionTitle": "A. 结构型模式可以在不破坏类封装性的基础上，实现新的功能"
},
{
"optionId": "B",
"optionTitle": "B. 结构型模式主要用于创建一组对象"
},
{
"optionId": "C",
"optionTitle": "C. 结构型模式可以创建一组类的统一访问接口"
},
{
"optionId": "D",
"optionTitle": "D. 结构型模式可以在不破坏类封装性的基础上，使得类可以通不曾估计到的系统进行交互"
}
],
"subjectId": "",
"subjectTitle": "设计模式中关于结构型模式，以下说法正确的是",
"subjectType": 2
},
{
"answer": "B&D",
"optionList": [
{
"optionId": "A",
"optionTitle": "A. 基本类型偏执(Primitive Obsession)"
},
{
"optionId": "B",
"optionTitle": "B. 散弹式修改(Shotgun Surgery)"
},
{
"optionId": "C",
"optionTitle": "C. 过长参数列表(Long Parameter List)"
},
{
"optionId": "D",
"optionTitle": "D. 发散式变化(Divergent Change)"
}
],
"subjectId": "",
"subjectTitle": "面向对象设计的基本原则中的开闭原则指出软件要对扩展开放，对修改关闭。违反开闭原则可能造成的坏味道有",
"subjectType": 2
},
{
"answer": "错",
"optionList": [],
"subjectId": "",
"subjectTitle": "敏感对象发送出信任域前应该先加密然后再签名。",
"subjectType": 3
},
{
"answer": "错",
"optionList": [],
"subjectId": "",
"subjectTitle": "当实现Socket通信模块时，若需要保证传输数据的安全性，可以考虑使用java.net.Socket来建立安全的网络传输通道。",
"subjectType": 3
},
{
"answer": "B&C&D",
"optionList": [
{
"optionId": "A",
"optionTitle": "A、输出敏感信息"
},
{
"optionId": "B",
"optionTitle": "B、流未正确释放"
},
{
"optionId": "C",
"optionTitle": "C、代码存在命令注入风险"
},
{
"optionId": "D",
"optionTitle": "D、进程阻塞在输入输出流上"
}
],
"subjectId": "",
"subjectTitle": "对于以下代码实现关于存在的安全风险，下列说法正确的是（）\r\nclass DirList{\r\n public static void main(String[] args) throws Exception{\r\n String dir = Systeim.getProperty( 'dir' );\r\n Runtime rt = runtime.getRuntime();\r\n Process proc = rt.exec /C dir '+ dir);\r\n int result = proc.waitFor();\r\n if (result != 0){\r\n System.out.printIn( 'process error: '+ result);\r\n }\r\n InputStream in = (result==0)? proc.getInputStream();\r\n proc.getErrorStream();\r\n intc;\r\n while((c = in.read()!=-1){\r\n System.out.print((char) c);\r\n }\r\n }\r\n}",
"subjectType": 2
},
]
【最新修正： 过滤内容行，优化答案行】
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
默认导入以下6行式的题目
关于可靠性和可用性间的关系，下列哪种说法是正确的？
A. 可靠性等同于可用性
B. 高可用性除了要求具有高可靠性外，还必须具有良好的可维修性
C. 可靠性和可用性是两个概念，两者间没有关系
D. 可用性只与可靠性相关，与可维修性无关
B
下面哪些设计是符合权限最小化要求的？（）
A. 一个帐号只能拥有该角色必需的权限，不分配不必要的权限。
B. 权限划分的粒度尽可能最小化，帐号权限应基于“need-to-know”和“case-by-case”的原则。
C. 为保证有足够权限读取到数据，连接Web服务数据库应该使用Administrator帐号。
D. 审计日志只有管理员或日志审计员有权限读取，普通用户无法访问读取。
ABD
选项ABCD支持 空白 . , 、 ， 【分别是 空白 英文点号，英文逗号，中文顿号，中文逗号 】
【最新修正： 过滤内容行，优化答案行】
"""
import sys
import time
import datetime
import json
import re
import codecs
reload(sys)
sys.setdefaultencoding('utf8')
file = open("questions.txt", mode='r')
txt_lines = file.readlines()
# 【最新修正：过滤内容行：过滤一两三个空格这种内容行，过滤5 77这种序号行】
def filter_line_func(line):
if line == "":
return True
if line == "\n":
return True
linestrip = line.strip()
if linestrip == "":
return False
if linestrip.isdigit():
return False
return True
txt_new_lines = filter(filter_line_func, txt_lines)
#strtime = (datetime.datetime.now() - datetime.timedelta(hours=1)).strftime("%Y%m%d%H%M%S")
strtime = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
# 备份questions.txt
file1 = open("{}-questions.txt".format(strtime), mode='w')
file1.writelines(txt_new_lines)
# import pdb
# pdb.set_trace()
txt = "".join(txt_new_lines)
# print(txt)
questions = re.split("\n\n+", txt)
def make_question(content_lines):
# 先排空
if not content_lines:
return {}
answer = content_lines[-1]
if answer == "对" or answer == "错":
subjectType = 3 # 判断题
title = "\r\n".join(content_lines[:-1])
optionList = []
return {"subjectTitle": title, "subjectType": subjectType, "answer": answer, "optionList": optionList, "subjectId": ""}
answer_line = -1
option_separator = " "
# 查找选项的第一行，之前的行作为title
for line in content_lines:
answer_line += 1
if line.startswith("A、"):
option_separator = "、"
break
if line.startswith("A."):
option_separator = "."
break
if line.startswith("A,"):
option_separator = ","
break
if line.startswith("A，"):
option_separator = "，"
break
if line.startswith("A "): # 单独的A加空格，再往下找B，才能准确
if content_lines[answer_line].startswith("B"):
break
# 优化答案行 最后一行如果不符合答案行要求，则置空
answer = content_lines[-1]
if re.match( r'[A-N]+$', answer):
options = content_lines[answer_line:-1]
else:
answer = ""
options = content_lines[answer_line:]
optionList = []
for line2 in options:
# split带参数1，分隔成两个
# optionId = line2.split(option_separator, 1)[0] # 没必要这么复杂，直接取第一个字符即可
optionId = line2[0]
optionList.append({"optionId": optionId, "optionTitle": line2})
if answer_line == 1:
title = content_lines[0]
else:
title = "\r\n".join(content_lines[:answer_line])
# if answer == "对" or answer == "错":
# subjectType = 3 # 判断题 的逻辑单独提到前面去了
if len(answer) == 1:
subjectType = 1 # 单选题
else:
subjectType = 2 # 多选题
answer = "&".join(answer)
# return title, optionList, answer, subjectType
return {"subjectTitle": title, "subjectType": subjectType, "answer": answer, "optionList": optionList, "subjectId": ""}
outputs = []
outputs.append("[")
for question in questions:
if question == "":
continue
items = question.split("\n")
try:
json_item = make_question(items)
if json_item:
item_json = json.dumps(json_item, sort_keys=True, indent=4, ensure_ascii=False)
print(item_json)
outputs.append(item_json + ",")
except:
print(">>> error occur\n")
print(questions)
pass
outputs.append("]")
file2name = "{}-exam.json".format(strtime)
file2 = open(file2name, mode='w')
file2.write("\n".join(outputs))
# 如果要指定utf8编码
# file2 = open(file2name, mode='w', encoding='utf-8') # python3
# file2 = codecs.open(file2name, 'w', 'utf-8') # python2.7
最新版本 class Question
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
默认导入以下6行式的题目
关于可靠性和可用性间的关系，下列哪种说法是正确的？
A. 可靠性等同于可用性
B. 高可用性除了要求具有高可靠性外，还必须具有良好的可维修性
C. 可靠性和可用性是两个概念，两者间没有关系
D. 可用性只与可靠性相关，与可维修性无关
B
下面哪些设计是符合权限最小化要求的？（）
A. 一个帐号只能拥有该角色必需的权限，不分配不必要的权限。
B. 权限划分的粒度尽可能最小化，帐号权限应基于“need-to-know”和“case-by-case”的原则。
C. 为保证有足够权限读取到数据，连接Web服务数据库应该使用Administrator帐号。
D. 审计日志只有管理员或日志审计员有权限读取，普通用户无法访问读取。
ABD
选项ABCD支持 空白 . , 、 ， 【分别是 空白 英文点号，英文逗号，中文顿号，中文逗号 】
【最新修正： 过滤内容行，优化答案行】
"""
import sys
import time
import datetime
import json
import re
import codecs
reload(sys)
sys.setdefaultencoding('utf8')
#strtime = (datetime.datetime.now() - datetime.timedelta(hours=1)).strftime("%Y%m%d%H%M%S")
strtime = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
file0 = open("questions.txt", mode='r')
def get_question_lines_1():
txt = file0.read()
questions = re.split("\n\n+", txt)
# 备份questions.txt
file1 = open("{}-questions.txt".format(strtime), mode='w')
file1.write(txt)
file1.close()
file0.close()
return questions
def get_question_lines_2():
txt_lines = file0.readlines()
# 【最新修正：过滤内容行：过滤一两三个空格这种内容行，过滤5 77这种序号行】
def filter_line_func(line):
if line == "":
return True
if line == "\n":
return True
linestrip = line.strip()
if linestrip == "":
return False
if linestrip.isdigit():
return False
return True
txt_new_lines = filter(filter_line_func, txt_lines)
txt = "".join(txt_new_lines)
# print(txt)
questions = re.split("\n\n+", txt)
# 备份questions.txt
file1 = open("{}-questions.txt".format(strtime), mode='w')
file1.writelines(txt_new_lines)
file1.close()
file0.close()
return questions
class Question(object):
def __init__(self, subjectTitle, optionList=[], subjectType=1, answer="", subjectId=""):
self.subjectTitle = subjectTitle
self.optionList = optionList
self.subjectType = subjectType
self.subjectId = subjectId
self.answer = answer
def get_json(self):
json_item = {"subjectTitle": self.subjectTitle,
"subjectType": self.subjectType,
"answer": self.answer,
"optionList": self.optionList,
"subjectId": self.subjectId}
item_json = json.dumps(json_item, sort_keys=True, indent=4, ensure_ascii=False)
print(item_json)
return item_json
@staticmethod
def make_question(content_lines):
# 先排空
if not content_lines:
return
answer = content_lines[-1]
if answer == "对" or answer == "错":
subjectType = 3 # 判断题
title = "\r\n".join(content_lines[:-1])
optionList = []
return Question(title, optionList, subjectType, answer)
answer_line = -1
option_separator = " "
# 查找选项的第一行，之前的行作为title
for line in content_lines:
answer_line += 1
if line.startswith("A、"):
option_separator = "、"
break
if line.startswith("A."):
option_separator = "."
break
if line.startswith("A,"):
option_separator = ","
break
if line.startswith("A，"):
option_separator = "，"
break
if line.startswith("A "): # 单独的A加空格，再往下找B，才能准确
if content_lines[answer_line].startswith("B"):
break
# 优化答案行 最后一行如果不符合答案行要求，则置空
answer = content_lines[-1]
if re.match( r'[A-N]+$', answer):
options = content_lines[answer_line:-1]
else:
answer = ""
options = content_lines[answer_line:]
optionList = []
for line2 in options:
# split带参数1，分隔成两个
# optionId = line2.split(option_separator, 1)[0] # 没必要这么复杂，直接取第一个字符即可
optionId = line2[0]
optionList.append({"optionId": optionId, "optionTitle": line2})
if answer_line == 1:
title = content_lines[0]
else:
title = "\r\n".join(content_lines[:answer_line])
# if answer == "对" or answer == "错":
# subjectType = 3 # 判断题 的逻辑单独提到前面去了
if len(answer) == 1:
subjectType = 1 # 单选题
else:
subjectType = 2 # 多选题
answer = "&".join(answer)
# return title, optionList, answer, subjectType
return Question(title, optionList, subjectType, answer)
def main():
outputs = []
outputs.append("[")
questions = get_question_lines_2()
for question in questions:
if question == "":
continue
items = question.split("\n")
try:
json_item = Question.make_question(items)
if json_item:
item_json = json_item.get_json()
outputs.append(item_json + ",")
except:
print(">>> error occur\n")
print(question)
outputs.append("]")
file2name = "{}-exam.json".format(strtime)
file2 = open(file2name, mode='w')
file2.write("\n".join(outputs))
# 如果要指定utf8编码
# file2 = open(file2name, mode='w', encoding='utf-8') # python3
# file2 = codecs.open(file2name, 'w', 'utf-8') # python2.7
file2.close()
main()
导入questions