OOP题目集4~6的总结

目录

（一）前言

（二）作业介绍

（三）算法与代码

（四）PowerDesigner类图模型

（五）SourceMonitor代码分析

（六）自学内容

（七）总结

一、前言

介绍本篇博客的大致内容、写作目的、意义等

本篇博客介绍如何使用Java语言基础和算法来解决题目问题，在此基础上进行对最近Java编程语言学习的总结

题目的难度为Java入门，主要考察 类的设计、类的继承与多态、集合（列表）、接口的使用 等一些基础算法以及一些自学内容

二、作业介绍

展示作业题目，并梳理算法思路

题目内容

第四~六次PTA作业共7大题，本篇博客将挑选其中难度最大的 两题 进行分析与总结：

题目（1）：

题目（2）：

答题判题程序 题目组共有四题， 家居强电电路模拟程序 题目组共有四题。其中上图的 * 答题判题程序-4* 是对 答题判题程序 -1~3 的增补和迭代，* 家居强电电路模拟程序-2* 是对 家居强电电路模拟程序 -1 的增补和迭代，下面内容将以这两题展开分析与总结

三、算法与代码

展示个人解决题目的算法思路以及答案

算法大纲

题目（1）：答题判题程序-4

Tips：

1、题目输入按照一定格式规律，因此可以运用正则表达式来高效处理输入数据，且处理输入时运用while( input.hasNextLine() ){ }循环，逐行收集输入信息，直到该行字符串为end时退出循环

2、在审阅题目（下两图）时，可以发现试卷信息、答卷信息格式较其他输入不同，多个【题目】—【分值】/【答题顺序】-【答案】共用一个【试卷编号】/【答卷编号】，即输入信息有阶级关系，因此需要在试卷类和答卷类中额外创建一个集合来存放和引用输入信息。而集合(Linked)Hashmap的特点适合这种格式，因此将会使用 Hashmap 和 LinkedHashMap（相关特点在自学内容中）

3、题目输出的错误提示较多且有优先级顺序输出，所以做题之前应做好输出提示的优先级排序，优先级越高的代码块 应越靠前/在越外层的循环

4、迭代新增填空题、多选题两种机制，需要实现多选题和填空题的答案核对功能（选项的顺序变化、答案部分正确的核分等），需要创建对应函数或方法来实现

本题需要创建：

类

  • 题目类class Question，包含：

    • 整型—num（题目编号）

    • 字符串型—content（题目内容）

    • 字符串型—standardanswer（标准答案）

    • 整型—score（题目分值）

    • 整型—flag（是否被删除：true=已被删除/false=未被删除）

    • 方法—Right_Result()（答题正确输出）

    • 方法—Wrong_Result( String wrong_answer )（答题错误输出）

  • 试卷类class Exam_paper，包含：

    • 整型—paper_num（试卷编号）
    • 链表LinkedHashMap<Integer,Integer> score_map——存放试卷中的题目及对应分值
    • 方法—put_score_map(int num, int score )（score_map添加新元素）
    • 方法—Check_total_score()（检测当前试卷是否满分为100分）

  • 学生类class Student，包含：

    • 字符串型—ID（学号）
    • 字符串型—name（姓名）

  • 答卷类class Answer，包含：

    • 整型—paper_num（答卷编号）
    • 字符串型—ID（学号）
    • 链表LinkedHashMap<Integer,String> answer_map——存放答卷中的答题顺序及对应答案
    • 方法—put_answer_map(int order, String answer )（answer_map添加新元素）

  • 删除题目类class Delete，包含：

    • 整型—delete_num（删除题目编号）

  • 比较器类class Comparable，包含：

    • 方法—int compare(Answer answer1 , Answer answer2 )

主函数

  • 数组列表List[Question] questionArrayList——存放 题目类 信息
  • 数组列表List[Exam_paper] exam_paperArrayList——存放 试卷类 信息
  • 数组列表List[Student] studentsArrayList——存放 学生类 信息
  • 数组列表List[Answer] answerArrayList——存放 答卷类 信息
  • 数组列表List[Delete] deleteArrayList——存放 删除题目类 信息
  • 链表LinkedList score——临时记录当前答卷人的各题赋分情况

个人思路：

	采用循环结构利用正则表达式逐行分析输入——>判断试卷分值——>记录删除的题目——>试卷赋分——>核对试卷与答卷编号——>按照试卷顺序去答卷中查找试卷题号——>判断题目是否被删除——>判断答题是否正确（多选题和填空题调用相应核对答案的函数）并记录得分——>判断是否有题目漏答——>查找学生信息——>输出学生答题得分

题目（2）：家居强电电路模拟程序-2

Tips：

1、题目输入按照一定格式规律，因此可以运用正则表达式来高效处理输入数据，且处理输入时运用while( input.hasNextLine() ){ }循环，逐行收集输入信息，直到该行字符串为end时退出循环

2、题目用到的类较多，且类与类之间存在继承与多态的关系，因此需要按优先级顺序做好类的设计。且由于所有的设备都有共同的属性：输入引脚、输出引脚、电阻（无=0），所以可以设计一个最高父类Device，并包含以上元素

3、由于串联和并联电路同样也含有上述属性，因此串并联电路也可以看作一个元件，继承Device

4、并联电路其实是由若干个串联电路组成，因此并联电路的属性可以设计为存放串联电路对象的列表

5、在审阅题目时，可以发现

1)像例如 [* K1-1] [K1-2 *] 的输入信息虽然出现了两次K1的信息，但其实只代表当前电路中只有一个K1，因此真正有效的信息是例如 K1] 的输入，因此在一次此格式的正则表达式匹配成功后，再实现对应类的创建

2)只有含有输入信息 [VCC 的电路是主电路，其他电路为支电路，因此可以创建一个临时电路类变量存放匹配到的主电路信息

本题需要创建：

类

  • <抽象>元件类class Device，包含：

    • int—num（编号）

    • double—input_pin1（输入引脚）

    • double—output_pin2（输出引脚）

    • double—PD（电压差）

    • double—resistance（电阻）

    • double—ratio（电压占比）

    • 方法—Show()（打印输出）

  • <继承-原件类>开关类class ON_OFF，除继承属性外包含：

    • String—status（状态）

    • 方法—void Judging_Output(double input_pin)（根据开关状态，判断输出电压）

  • <继承-原件类>分档调速器类class Split_Speeder，除继承属性外包含：

    • int—current_gear（当前档位）

    • 链表LinkedHashMap<Integer,Float> Gears——存放分档调速器中的档位及对应电压输出比值

    • 方法—Gear_Adjust(String status)（根据状态，设置当前档位）

    • 方法—Gear_Voltage( double input )（根据档位，输出电位）

  • <继承-原件类>连续调速器类class Continuous_Speeder，除继承属性外包含：

    • double—parameter（档位参数）

    • 方法—Proportional_calculate()（计算正比电压差）

  • <继承-原件类>串联电路类class Series_Circuit，除继承属性外包含：

    • boolean—running（是否可运行）
    • 链表ArrayList device_list——存放当前电路的电子元件

  • <继承-原件类>并联电路类class Parallel_Circuit，除继承属性外包含：

    • boolean—running（是否可运行）
    • 链表ArrayList<Series_Circuit> SUB_Series_list——存放当前并联电路中的子串联电路

  • <继承-原件类>白炽灯类class Incandescent_Lamp，除继承属性外包含：

    • double—Brightness_lux（流明值）
    • 方法—Brightness_calculate()（根据输入电压计算亮度）

  • <继承-原件类>日光灯类class Fluorescent_Lamp，除继承属性外包含：

    • double—Brightness_lux（流明值）
    • 方法—Brightness_calculate()（根据输入电压计算亮度）

  • <继承-原件类>吊扇类class Ceiling_Fan，除继承属性外包含：

    • int—Speed（转速值）
    • 方法—Speed_calculate()（根据输入电压计算转速）

  • <继承-原件类>落地扇类class Ground_Fan，除继承属性外包含：

    • int—Speed（转速值）
    • 方法—Speed_calculate()（根据输入电压计算转速）

主函数

  • 链表ArrayList<Series_Circuit> series_circuit_list——存放 串联电路类 信息

  • 链表ArrayList<Parallel_Circuit> parallel_circuit_list——存放 并联电路类 信息

个人思路：

	采用循环结构利用正则表达式逐行收集输入信息，并标注主电路信息——>判断所有电路开关情况——>根据调速器更新电压——>计算电路电阻——>根据电阻计算比例ratio——>根据开关情况，主电路流入电流——>输出结果

代码大纲

题目（1）：

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;//题目基本信息
class Tittle
{}//1、题目信息  "#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
class Question extends Tittle
{}//2、试卷信息  "#T:"+试卷号+" "+题目编号+"-"+题目分值
class Exam_paper
{}//3、学生信息  "#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名
class Student
{}//4、答卷信息  **"#S:"+试卷号+" "+"#A:"+答案内容**
class Answer
{}class Delete
{}class Comparable implements Comparator<Answer>
{}public class Main
{public static void main(String[] args){Scanner input = new Scanner(System.in);String regex_Question = "#N:\\s*(\\d+)\\s*#Q:(.+) #A:(.+)";Pattern pattern_Question = Pattern.compile(regex_Question);·········List<Question> questionArrayList = new ArrayList<>();·········//输入while( input.hasNextLine() ){//当前一行的输入字符串String inputString = input.nextLine();Matcher pmatcher_Question = pattern_Question.matcher(inputString);·········//输入字符串是end，则输入完毕退出循环if(inputString.equals("end"))break;//inputString==输入1、题目信息  "#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案else if(pmatcher_Question.matches()){Question question = new Question(Integer.parseInt(pmatcher_Question.group(1).trim()), pmatcher_Question.group(2).trim(), pmatcher_Question.group(3).trim());questionArrayList.add(question);}else·········//输入信息只要不符合格式要求，均输出”wrong format:”+信息内容       例如：wrong format:2 #Q:2+2=else{System.out.println("wrong format:"+inputString);}}//总while结束//判断试卷分值是否100·········if( exam_paperArrayList.size()==0 ){Exam_paper exam_paper = new Exam_paper( 0 );exam_paper.put_score_map( 0 , 0 );exam_paperArrayList.add(exam_paper);}//删除题目并记录·········//排序answerArrayListComparable comparable = new Comparable();answerArrayList.sort(comparable);for( int S=0;S<answerArrayList.size();S++ )  //几份答卷{//搜索答卷对应试卷号·········for( int T=0;T<exam_paperArrayList.size();T++ )  //几份试卷分则{//判断试卷编号是否相同,搜到了对应试卷号···//当前试卷题目赋分值···{//根据#T 搜索题号···//搜到了题号···//记录分数//LinkedList<Integer> score = new LinkedList<>();//检测#A···//循环查找题目···//搜索当前题号current_num信息···//找到current_num题目···//题目有效···//判断是否答对  计算分数···//#S:里的#A:答了删除的题目                             ···//没找到···}//输入的#A检测完//#S：里的#A: < #T里的个数  输入的答案信息少于试卷的题目数量···//搜索学生···//#S:里的学号在#X:里没有  学号引用错误 ···//记录输出分数格式···//#S:里的paper_num和#T:里的papernum不等  试卷号引用错误···//自定义函数：判断填选答案情况public static Boolean Including( String A,String a ){if( a.isEmpty() )return false;for( int i=0;i<a.length();i++ ){char c=a.charAt(i);if ( !A.contains(String.valueOf(c)) ){return false;}}return true;}}

题目（2）：

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;abstract class Device
{}// K 开关
class ON_OFF extends Device
{}// F 分档调速器
class Split_Speeder extends Device
{}// L 连续调速器
class Continuous_Speeder extends Device
{}//串联电路
class Series_Circuit extends Device
{}//并联电路
class Parallel_Circuit extends Device
{}// B 白炽灯
//亮度在 0~200lux（流明）之间。
//电位差为 0-9V 时亮度为 0,电位差 10V 对应 50ux，220V 对应200lux
//其他电位差与对应亮度值成正比。
class Incandescent_Lamp extends Device
{}// R 日光灯
//亮度为 180lux。
//电位差为 0时亮度为 0，电位差不为 0时亮度为 180。
class Fluorescent_Lamp extends Device
{}// D 吊扇
// 工作电压区间为 80V-150V
// 80V 对应转速为 80转/分钟，150V 对应转速为 360 转/分钟，超过 150V 转速为 360 转/分钟
// 其他电压值与转速成正比，输入输出电位差为 0 时转速为 0。
class Ceiling_Fan extends Device
{}//落地扇
//工作电压区间为 80V-150V
//80V-99V  80 转/分 钟，100-119V  160 转/分钟，120-139V  260 转/分钟，超过 140V 转速 为 360 转/分钟
class Ground_Fan extends Device
{}class Main
{public static void main(String[] args){Scanner input = new Scanner(System.in);//主电路Series_Circuit main_circuit = new Series_Circuit();//源电压double V = 220.0;//默认VCC//地电压double G = 0.0;//默认接地ArrayList<Series_Circuit> series_circuit_list = new ArrayList<>();ArrayList<Parallel_Circuit> parallel_circuit_list = new ArrayList<>();while (input.hasNextLine()){//当前一行的输入字符串String inputString = input.nextLine();//#T(*):Pattern pattern_T = Pattern.compile("#T(\\d+):");Matcher matcher_T = pattern_T.matcher(inputString);//#M(*):Pattern pattern_M = Pattern.compile("#M(\\d+):");Matcher matcher_M = pattern_M.matcher(inputString);//串联或并联电路信息//串联信息if(matcher_T.find()){int current_num = Integer.parseInt(matcher_T.group(1));//创建串联电路Series_Circuit series_circuit = new Series_Circuit(current_num);series_circuit_list.add(series_circuit);//[* *]Pattern pattern_information = Pattern.compile("\\[(\\S+)\\s(\\S+)\\]");Matcher matcher_information = pattern_information.matcher(inputString);//循环提取电路信息while(matcher_information.find()){·········}//【VCCif(inputString.contains("VCC")){V = 220.0;series_circuit.input_pin1 = V;//记录主电路main_circuit=series_circuit;}}//并联信息else if(matcher_M.find()){·········}//串联或并联电路信息录入结束//【K*】——调节开关Pattern pattern_K = Pattern.compile("#(K)(\\d)");Matcher matcher_K = pattern_K.matcher(inputString);//【F*+\-】——调节分档调速器档位Pattern pattern_F = Pattern.compile("#(\\w)(\\d)(\\+|\\-)");Matcher matcher_F = pattern_F.matcher(inputString);//【L*】——调节连续调速器参数Pattern pattern_L = Pattern.compile("#(\\w)(\\d):(\\d+\\.?\\d*)");Matcher matcher_L = pattern_L.matcher(inputString);//输入字符串是end，则输入完毕退出循环if (inputString.equals("end"))break;//inputString== #K*  ——调节开关else if (matcher_K.matches()){//获取当前开关编号···//在series_circuit_list，找到其中编号为current_num的开关···//开关状态反转···}//inputString== #F*+\-  ——调节分档调速器档位else if (matcher_F.matches()){···//获取当前分档调速器编号···//在series_circuit_list，找到其中编号为current_num的分档调速器···}//inputString== #L*:*(.*)  ——调节连续调速器参数else if (matcher_L.matches()) {//获取当前连续调速器编号···//在series_circuit_list，找到其中编号为current_num的连续调速器···}}//总while结束//判断所有电路开关情况·········//根据调速器更新电压for(Device device : main_circuit.device_list){//按照线路处理电器if (device instanceof Split_Speeder){·········}}//计算电路电阻double Main_Sum_resistance = 0;for(Device device : main_circuit.device_list){//进入子并联电路if(device instanceof Parallel_Circuit){double Sub_Sum_resistance = 0;  //R累和double Pro_resistance = 1;      //R累积if(((Parallel_Circuit) device).running) //子并联电路运行{int count=0;·········//进入子串联电路for (Series_Circuit series_circuit : ((Parallel_Circuit) device).SUB_Series_list){·········}//子并联电路有多个子串联电路，并且电路都运行·········}}else Main_Sum_resistance += device.resistance;}·········//根据电阻计算比例ratio···//根据开关情况，main_circuit流入电流···//输出结果Show_Device(series_circuit_list);}//自定义函数：检测输入电器类型，创建对应对象public static void Check_Device(String input_String, double input_V, double output_V, Series_Circuit series_circuit){Pattern pattern_K = Pattern.compile("(K)(\\d)-(\\d)");Pattern pattern_F = Pattern.compile("(F)(\\d)-(\\d)");Pattern pattern_L = Pattern.compile("(L)(\\d)-(\\d)");Pattern pattern_B = Pattern.compile("(B)(\\d)-(\\d)");Pattern pattern_R = Pattern.compile("(R)(\\d)-(\\d)");Pattern pattern_D = Pattern.compile("(D)(\\d)-(\\d)");Pattern pattern_A = Pattern.compile("(A)(\\d)-(\\d)");Pattern pattern_M = Pattern.compile("M(\\d)-IN");Matcher matcher_K = pattern_K.matcher(input_String);Matcher matcher_F = pattern_F.matcher(input_String);Matcher matcher_L = pattern_L.matcher(input_String);Matcher matcher_B = pattern_B.matcher(input_String);Matcher matcher_R = pattern_R.matcher(input_String);Matcher matcher_D = pattern_D.matcher(input_String);Matcher matcher_A = pattern_A.matcher(input_String);Matcher matcher_M = pattern_M.matcher(input_String);·········}//自定义函数：//根据电阻计算比例ratiopublic static void Calculate_Ratio(Series_Circuit main_circuit){for (Device device : main_circuit.device_list){if (device.resistance != 0){·········}}}//自定义函数：//根据开关情况，main_circuit流入电流public static void Check_Main_Circuit( Series_Circuit main_circuit, double input_V, double output_V){double current_V = input_V;if(main_circuit.running){·········}}//自定义函数：//按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇的顺序依次输出所有设备的状态或参数。每个设备一行。同类设备按编号顺序从小到大输出。public static void Show_Device(ArrayList<Series_Circuit> series_circuit_list){ArrayList<Device> device_list = new ArrayList<>();//收集所有设备for (Series_Circuit series_circuit : series_circuit_list){device_list.addAll(series_circuit.device_list);}//按编号升序输出开关信息···//按编号升序输出分档调速器信息···//按编号升序输出连续调速器信息···//按编号升序输出白炽灯信息···//按编号升序输出日光灯信息···//按编号升序输出吊扇信息···//按编号升序输出落地扇信息···}}

四、PowerDesigner类图模型

题目（1）：

题目（2）：

五、SourceMonitor代码分析

题目（1）：

题目（2）：

六、自学内容

展示自学内容，并进行重点的归纳和整理（这里只展示个人认为比较重要且题目需要用到的知识点）

正则表达式

推荐正则表达式的网上测试工具网址：<正则表达式在线测试 | 菜鸟工具 (jyshare.com)>里面附带下图最基本的正则表达式语法参考

Pattern类 和 Matcher 方法

（1） Matcher 匹配器类，通过 Pattern 执行匹配操作，基本用法为：

Pattern [pattern名称] = Pattern.compile([正则表达式/固定字符串]);
Matcher [matcher名称] = [pattern名称].matcher([被匹配的字符串]);

（2）.matches() 方法：对整个字符串进行匹配，匹配成功返回true

例：正则表达式：\d+ //至少一个数字

  被匹配字符串：12345			//匹配成功被匹配字符串：12345abc      //匹配失败

//(1)代码
if( [matcher名称].matches() ){System.out.println("匹配成功");
}

（3）.find() 方法：对字符串进行局部匹配，匹配成功返回true

.find()方法在匹配后会从匹配部分的下个位置开始

例：正则表达式：\d+ //至少一个数字

  被匹配字符串：123abc			//匹配成功一次被匹配字符串：123abc123      //匹配成功两次

//(1)代码
if( [matches名称].find() ){System.out.println("匹配成功");
}

（4）.group() 方法：通过对括号内的字符分组，对每个组进行处理的方法

group( [组数] )，括号中的整型(>0) 对应 正则表达式中按括号分组的局部字符段；整型（=0）对应整个字符串

Pattern pattern = Pattern.compile("(\\w+)-(\\d+)");  	//[至少一个数字]-[至少一个字母]
Matcher matcher = pattern.matcher("a-1,b-b,c-3,d-d");
while ( matcher.find() )  	//循环局部匹配
{System.out.println("整组：" + matcher.group(0));System.out.println("组1：" + matcher.group(1));System.out.println("组2：" + matcher.group(2));
}

输出如图：

ArrayList 和 LinkedList

需要导入 java.util.Array 、java.util.LinkedList 包

异同：

相同处：没有固定大小的限制，可以添加或删除元素

不同处:1）ArrayList按线性的顺序存储数据；LinkedList是在每一个节点里存到下个节点地址的线性表

  	2）ArrayList适用频繁访问列表中的某个元素，查找和修改操作效率较低LinkedList需要通过循环迭代来访问列表中的元素，增加和删除操作效率较高

（1）创建

ArrayList<E> [表名称] =new ArrayList<>();  	//E—>泛型LinkedList<E> [表名称] = new LinkedList<E>();  	//E—>泛型，普通创建
LinkedList<E> [表名称] = new LinkedList(Collection<? extends E> c); 	 //E—>泛型，集合创建

（2）.add() 方法：添加元素

List.add( [元素] );  	//尾插一个新元素

（3）. get() 方法：访问元素

List.get( n-1 );  	//访问第n个元素

（4）size() 方法：计算大小

List.size();  	//返回整型=表的元素个数

（5）for each 方法：迭代遍历

for ( [元素类型] [循环变量] : [表名称] ) 
{System.out.println([循环变量]);
}

HashMap 和 LinkedHashMap

需要导入 java.util.HashMap 、java.util.LinkedHashMap 包

异同：

相同处：没有固定大小的限制的散列表，它存储的内容是键值对(key-value)映射

不同处:1）HashMap每次添加元素的存放位置是无序的；LinkedHashMap保证迭代顺序，即按 照储存顺序排列

  	2） LinkedHashMap额外加了 *头节点header*，*标志位accessOrder* 两个成员变量

（1）创建

HashMap<[key类型], [value类型]> [表名称] = new HashMap<{[key类型], [value类型]}>();  	//E—>泛型，{}中内容可以省略LinkedHashMap<[key类型], [value类型]> [表名称] = new LinkedHashMap<{[key类型], [value类型]}>();  	//E—>泛型，{}中内容可以省略

（2）.put() 方法：添加元素

Map.put( [key],[value] );  	//尾插一个新元素

（3）. get(key) 方法：访问键值对应映射值

Map.get( [key] );  	//访问key的value

（4）size() 方法：计算大小

Map.size();  	//返回整型=表的元素个数

（5）for each 方法：迭代遍历

// 输出 key 和 value
for ([key类型] key : [表名称].keySet() )   	//.keySet()方法当前获取键值
{System.out.println( "key: " + key + " value: " + [表名称].get(key) );
}

Comparator 和 Comparable方法

需要导入 java.util.Comparator 包

异同：

相同处：可以对 集合Collections 进行排序

不同处：Comparator 可以有更多的排序方法

数值排序

class [方法名称] implements Comparator<[排序对象类型]>
{public int compare( [排序元素1] , [排序元素2] )  	//Comparator接口的方法 int compare(object o1,object o2);{if([排序元素1]>[排序元素2]) return 1;else if([排序元素1]>[排序元素2])  return -1;else return 0;}
}

字符串排序

class [方法名称] implements Comparator<[排序对象类型]>
{public int compare( [排序元素1] , [排序元素2] )  	{return [排序元素1].compareTO( [排序元素2] );  	//.compareTo()方法用于字符串之间的比较}
}

Optional 类(数据流)

需要导入 java.util.Optional 包

可以保存类型的容器对象，可以很好的解决空指针异常问题

（1）创建

//在parallel_circuit_list中寻找编号为sub_num的对象Optional<Parallel_Circuit> FoundOptional = parallel_circuit_list.stream().filter(parallel_circuit ->  parallel_circuit.num == sub_num).findFirst();	//.findFirst()——找到第一个就返回该对象

（2）isPresent() 方法：对象存在则返回true

if( FoundOptional.isPresent() )  	//通过数据流找到相应元素
{//相应操作
}

七、总结

（1）面对家居强电电路模拟程序-2时，应提前做好类的设计，提前规划类图，确认类之间属性的公共性和对应方法体

（2）家居强电电路模拟程序-2 尤其体现了类的继承与多态，极大提升了代码的可复用性

（3）代码的质量仍待提高：比如类设计的单一职责原则、不必要的算法结构、过多的分支结构等问题使代码还有更多的可提升空间

E N D

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/721859.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

前端使用 Konva 实现可视化设计器（13）- 折线 - 最优路径应用【思路篇】

前端使用 Konva 实现可视化设计器（13）- 折线 - 最优路径应用【思路篇】

这一章把直线连接改为折线连接，沿用原来连接点的关系信息。关于折线的计算，使用的是开源的 AStar 算法进行路径规划，启发方式为 曼哈顿距离，且不允许对角线移动。请大家动动小手，给我一个免费的 Star 吧~ 大家如果发现了 Bug，欢迎来提 Issue 哟~ github源码 gitee源码 示…
阅读更多...
SpringBoot热部署设置

SpringBoot热部署设置

在使用SpringBoot进行开发过程中，我们往往会对代码进行反复修改并对项目进行部署查看效果，这时反复重启SpringBoot会很麻烦，因此使用热部署是提高开发效率的必备插件——“spring-boot-starter-test” <!--SpringBoot热部署依赖--> <dependency> <gr…
阅读更多...
redis zset源码

redis zset源码

zset底层是由hash字典和跳表实现的，字典存储member->分数的映射关系，这样根据membe查询score的 时间复杂度O为1 跳表可以理解为多个层级的有序链表，每个节点可能在不同层级上，通过在不同层级的跳跃查找，把查询时间复杂度降低到 Olgn 1.随机层数，只有0.25的概率升级层数…
阅读更多...
C++U7-08-拓扑排序

C++U7-08-拓扑排序

拓扑：是指把实体抽象成与其大小形状无关的点，把连接实体的线路抽象成线，研究这些点线之间的相连关系。而表示点和线之间关系的图就被称为拓扑结构图。 拓扑学原本是一个数学概念，描述的是几何图形或空间在连续改变形状后还能保持不变的性质，它只考虑物体间的位置关系而不考…
阅读更多...
管式土壤墒情监测仪：引领农业与环境研究的革命性工具

管式土壤墒情监测仪：引领农业与环境研究的革命性工具

在农业科技日新月异的今天，管式土壤墒情监测仪凭借其独特的优势，已逐步成为农业和环境领域不可或缺的研究装备。这款监测仪，基于先进的介电常数原理，以其卓越的精确度和强大的功能，为研究人员提供了详尽而深入的土壤墒情数据，为探索土壤状况揭开了新篇章。管式土壤墒情监…
阅读更多...
本地部署GLM-4-9B清华智谱开源大模型方法和对话效果体验

本地部署GLM-4-9B清华智谱开源大模型方法和对话效果体验

清华大学和智谱AI推出了全面升级的新一代基座大模型GLM-4，整体性能相比GLM3提升60%，支持128K上下文，可根据用户意图自主理解和规划复杂指令、完成复杂任务……GLM-4-9B是清华大学和智谱AI推出的最新一代预训练模型GLM-4系列中的开源版本。在语义、数学、推理、代码和知识等多…
阅读更多...
minos 2.5 中断虚拟化——vGIC

minos 2.5 中断虚拟化——vGIC

首发公号：Rand_cs这一节开始讲述真正的中断虚拟化，首先来看硬件方面的虚拟化。前文 minos 2.3 中断虚拟化——GICv2 管理 主要讲述 GICv2 的 Distributor 和 CPU Interface，在 Hypervisor 存在的情况下，它们都是为 Hypervisor 服务的。现在有了 vm，vm 里面的内核也需要操作…
阅读更多...
minos 2.6 中断虚拟化——虚拟中断子系统

minos 2.6 中断虚拟化——虚拟中断子系统

首发公号：Rand_csHypervisor 需要对每个虚机的虚拟中断进行管理，这其中涉及的一系列数据结构和操作就是虚拟中断子系统 VIRQ 虚拟中断描述符 struct vcpu {uint32_t vcpu_id; .........../** member to record the irq list which the* vcpu is handling now*/struct virq_st…
阅读更多...
minos 1.2 内存虚拟化——guest

minos 1.2 内存虚拟化——guest

首发公号：Rand_csminos 1.2 内存虚拟化——guest项目来自乐敏大佬：https://github.com/minosproject/minos本文继续讲述 minos 中的内存虚拟化中关于 guest 的部分，主要弄清楚一个问题，minos 如何管理 guest vm 的内存。 对于虚拟机的内存管理主要是 ipa 的管理，ipa 如何映…
阅读更多...
minos 2.1 中断虚拟化——ARMv8 异常处理

minos 2.1 中断虚拟化——ARMv8 异常处理

首发公号：Rand_cs越往后，交叉的越多，大多都绕不开 ARMv8 的异常处理，所以必须得先了解了解 ARMv8 的异常处理流程 先说一下术语，从手册中的用词来看，在 x86 平台，一般将异常和中断统称为中断，在 ARM 平台，一般将中断和异常统称为异常 异常的流程，可以分为 3 个阶段，…
阅读更多...
NSSCTF———MISC

NSSCTF———MISC

[NISACTF 2022]huaji？ [SWPU 2020]套娃 [LitCTF 2023]What_1s_BASE (初级) [SWPUCTF 2021 新生赛]gif好像有点大 [NISACTF 2022]为什么我什么都看不见 [LitCTF 2023]404notfound (初级) [LitCTF 2023]这羽毛球怎么只有一半啊（恼 (初级) [LitCTF 2023]喜欢我的压缩包么 (初级)…
阅读更多...
BLP 模型

BLP 模型

公号：Rand_csBLP 模型 本篇文章是调研了许多资料后对 BLP 模型的一个总结 MLS，Multi-level Security，主要关心的是数据机密性 D. Elliott Bell 和 Leonard J. LaPadula 在 1996 年提出了基本的 BLP 模型，主要有两个性质：The Simple Security Property states that a subje…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023