OOP第三阶段题目集总结|课程总结-22201608-柯汶君
第三阶段的题目集时间跨度大，内容比较充实，对前面学习过的类的继承，多态，接口进行了巩固练习，加深我们对多态的理解，学会更好地改善代码的结构。同时对最后阶段所学习的集合框架体系（Set、Map等）比较方便的工具进行相应的练习，让我们通过合理地使用这些工具来减少代码复杂度。
前言：
1.作业相关知识点：
第七次和第八次题目集主要是对类的继承，多态和接口的巩固练习；
第九次题目集是课上讲完Set后对（Set和Map）利用的实践；
第十、十一、十二次题目集有成绩统计系统的迭代，同时对容器和前面学习过的类的基础知识进行复习。
2.作业题量：
每次题目集是为了对所学知识有一定的实践意义，题量与时间相关，比较正常；
3.作业难度：
复习回顾性的题目集的难度不大，重点是统计关键字和课程成绩统计，写起来繁琐，需要理解题目需求及类与类之间的关系。
设计与分析：
1.关键词统计：
题目分析：
题目要求对输入的源码进行关键词的查找（注释及字符串中的关键词不进行统计），当未输入源码时，程序输出Wrong Format当没有统计数据时，输出为空，当有统计数据时，关键字按照升序排列，每行输出一个关键字及数量，格式为数量\t关键字。
输出格式的要求可以通过（Map 把关键词当key存入，数量作为值）来满足，记得先对Map进行初始化，再使用，避免null的报错。将读取数据作为一个类，按行存入，再对每行除去字符串中的内容及非英文单词的部分（一些其他符号），然后按空格分割得到每一个代码中的词再与java中的53个关键词进行匹配，处理完后进行相应的输出。
类图：
作了输入和处理两个类，在Main中对结果进行输出
SourceMonitor分析：
这次题目用到了Map和Set代码的长度不大，同时涉及的分支很少，圈复杂度等不高，都在正常的范围之中。
完整代码：
查看代码
import java.util.*;
class InputData {
public static StringBuilder getData() {
StringBuilder stringBuilder = new StringBuilder();
String line;
while (!(line = Main.input.nextLine()).equals("exit")) {
//去掉单行注释和字符串里的内容
//.匹配这个字符多次，*字符后的内容
// /n 作为每行之间的特殊字符便于后续分割
stringBuilder.append(line.replaceAll("//.*", "").replaceAll("\".*\"", "")).append("\n");
}
return stringBuilder;
}
}
class DealData {
private Map<String, Integer> countMap = new TreeMap<>(); // 键值对（关键词 出现次数）
private final Set<String> keyWords = new HashSet<>(Arrays.asList(
"abstract", "assert", "boolean", "break", "byte", "case", "catch",
"char", "class", "const", "continue", "default", "do", "double", "else", "enum",
"extends", "for", "final", "finally", "float", "goto", "if", "implements", "import",
"instanceof", "int", "interface", "long", "native", "new", "package", "private",
"protected", "public", "return", "short", "static", "strictfp", "super", "switch",
"synchronized", "this", "throw", "throws", "transient", "try", "void", "volatile",
"while", "true", "false", "null"));
public Map<String, Integer> getCountMap() {
return countMap;
}
public String[] remove(StringBuilder stringBuilder) {
//去掉多行注释
int startIndex = stringBuilder.indexOf("/*");
while (startIndex != -1) {
int endIndex = stringBuilder.indexOf("*/", startIndex + 2);
if (endIndex == -1) {
break;
}
stringBuilder.replace(startIndex, endIndex + 1, "");
startIndex = stringBuilder.indexOf("/*");
}
stringBuilder.toString().replaceAll(",", " ");
String str = stringBuilder.toString();
/*运算符加上关键词应该不算关键词
所以要把带运算符的关键词作为非处理
*/
//通过改变运算符使整体不再是关键词
str = str.replace("-", "k").replace("*", "w").replace("/", "j");
str = str.replace("+", "h").replace(">", "y").replace("=", "y");
str = str.replace("!", "s");
str = str.replace(":", "s");
//匹配非字母项为空格，再用多空格分割每一块代码
String[] strings = str.replaceAll("[^a-zA-Z]", " ").split("\\s+");
return strings;
}
public void count(String[] codes) {
for (String keyword : keyWords) { // map初始化
countMap.put(keyword, 0);
}
//把每个代码词块都单独拿出来，再与关键词一一匹配
for (String code : codes) {
for (String keyword : keyWords) {
if (code.equals(keyword)) {
countMap.put(keyword, countMap.get(keyword) + 1);
}
}
}
}
}
public class Main {
public static Scanner input = new Scanner(System.in);
public static void main(String[] args) {
DealData dealData = new DealData();
StringBuilder data = InputData.getData();
//进行结果的输出
if(data.length() == 0) {
System.out.println("Wrong Format");
} else {
String[] codes = dealData.remove(data);
dealData.count(codes);
for (Map.Entry<String, Integer> entry : dealData.getCountMap().entrySet()) {
if(entry.getValue() > 0) {
System.out.println(entry.getValue()+ "\t" +entry.getKey());
}
}
}
}
}2.课程成绩统计程序-1：
题目分析：
首先要读取输入的课程信息，并进行存储，然后读取选课的信息（这里可以通过输入的格式进行区分），同时要注意格式不正确的输入要进行删除同时输出（wrong format);
我的思路是先读取信息，对信息作正确检测，然后再把正确的选课信息进行处理，读取与处理是两个类。在处理选课的同时，创建每个学生（不允许重复学号），将成绩存储给学生和课程；
最后把课程，学生，班级成绩的输出放在一个类中，在三个方法中进行相应的输出。
类图：
题目所给类图：
实际类图：
学生，课程，班级中都涉及到了成绩，成绩作为父类分为考试成绩和考察成绩两个子类，对应相应的课程，选课信息的组成有学生，课程，成绩三部分。通过Comparable接口重写compareTo方法来实现相应的排序。
SourceMonitor分析：
在对输入的信息进行分类及相应格式正确性的判断上使用了较多的if-else语句，导致最大圈复杂度过高，类中方法代码过于冗杂。
完整代码：
查看代码
import java.text.Collator;
import java.util.*;
class Student implements Comparable<Student>{
private String id;
private String name;
private ArrayList<Score> scores = new ArrayList<>();
public Student(String id, String name) {
this.id = id;
this.name = name;
}
public String getId() {
return id;
}
public String getName() {
return name;
}
public ArrayList<Score> getScores() {
return scores;
}
public void addScore(Score score) {
scores.add(score);
}
@Override
public int compareTo(Student student) {
return this.id.compareTo(student.id);
}
}
class Curriculum implements Comparable<Curriculum>{
private String curriculumName;
private String curriculumNature; // 课程性质
private String assessmentMethod; // 考核方式
private ArrayList<Score> scores = new ArrayList<>(); // 这门课程的全部成绩
public Curriculum(String curriculumName, String curriculumNature, String assessmentMethod) {
this.curriculumName = curriculumName;
this.curriculumNature = curriculumNature;
this.assessmentMethod = assessmentMethod;
}
public String getCurriculumName() {
return curriculumName;
}
public String getAssessmentMethod() {
return assessmentMethod;
}
public ArrayList<Score> getScores() {
return scores;
}
public void addScore(Score score) {
scores.add(score);
}
@Override
public int compareTo(Curriculum curriculum) { // 英文字母在汉字前面
return Collator.getInstance(Locale.CHINA).getCollationKey(this.curriculumName).
compareTo(Collator.getInstance(Locale.CHINA).getCollationKey(curriculum.curriculumName));
}
}
class Klass implements Comparable<Klass>{
private ArrayList<Student> students = new ArrayList<>();
private String classId;
public Klass(String classId) {
this.classId = classId;
}
public String getClassId() {
return classId;
}
public ArrayList<Student> getStudents() {
return students;
}
public void addStudents(Student student) {
this.students.add(student);
}
@Override
public int compareTo(Klass klass) {
return this.classId.compareTo(klass.classId);
}
}
abstract class Score {
protected int score;
protected boolean isLegal = true;
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public int getUsualScore() { // 让ExamScore重写该方法
return 0;
}
public int getFinalScore() {
return 0;
}
}
class ExamScore extends Score{
private int usualScore;//平时成绩
private int finalScore;//期末成绩
public ExamScore(int usualScore, int finalScore) {
this.usualScore = usualScore;
this.finalScore = finalScore;
this.score = (int)(0.3*usualScore + 0.7*finalScore);
}
public int getUsualScore() {
return this.usualScore;
}
public int getFinalScore() {
return this.finalScore;
}
}
class ExamineScore extends Score{
public ExamineScore(int score) {
this.score = score;
}
}
class CurriculumSelection {
private Curriculum curriculum;
private Student student;
private Score score; // 学生这门课的成绩
public CurriculumSelection(Curriculum curriculum, Student student, Score score) {
this.curriculum = curriculum;
this.student = student;
this.score = score;
}
}
class CleanData {
public static ArrayList<Curriculum> allCurriculums = new ArrayList<>(); // 所有课程信息
public static ArrayList<String[]> curriculumSelections = new ArrayList<>(); // 所有选课信息
public static void GetAllCurriculums() {
String line;
while (!(line = Main.input.nextLine()).equals("end")) {
String[] parts = line.split("\\s+");
boolean isRight = true;
boolean isExist = false;
boolean isCourseExist = false;
if(parts.length <= 5 && parts.length >3 && parts[0].matches("\\d{8}") && parts[1].length() <= 10 && parts[2].length() <= 10
&& parts[3].matches("^[0-9]\\d?$|^100$")) {
for (Curriculum c : allCurriculums) {
if (c.getCurriculumName().equals(parts[2]) ) {
isCourseExist = true;
if (parts.length > 4 && c.getAssessmentMethod().equals("考试")) {
break;
} else if (parts.length == 4 && c.getAssessmentMethod().equals("考察")) {
break;
} else {
isRight = false;
parts[2] = "kwj";
}
}
}
if(!isCourseExist) {
System.out.println(parts[2] + " does not exist");
}
if (!isRight) {
System.out.println(parts[0] + " " +parts[1] + " " + ":" + " access mode mismatch");
}
if (curriculumSelections.size()!=0) {
for(String[] s:curriculumSelections) {
if (s[0].equals(parts[0]) && s[2].equals(parts[2]) && !s[2].equals("kwj") ) {
isExist = true;
}
}
}
if ( !isExist ) {
curriculumSelections.add(parts);
} else if (!isRight || isExist) {
int a = 0;
} else {
System.out.println("wrong format");
}
}
else if ((parts.length == 2 || parts.length ==3) && !parts[0].matches("\\d+") ) {
if(parts.length == 3 && parts[1].equals("必修") && parts[2].equals("考察") ) {
System.out.println( parts[0] + " : course type & access mode mismatch");
} else {
boolean isCurriculumExist = false;
boolean isCurriculumRight = true;
if (parts.length == 3 && (parts[0].length() > 10 || (!parts[1].equals("必修") && !parts[1].equals("选修")) ||
(!parts[2].equals("考试") && !parts[2].equals("考察"))) ) {
System.out.println("wrong format");
isCurriculumRight = false;
}
if (parts.length == 2 && parts[1].equals("选修")) {
System.out.println("wrong format");
isCurriculumRight = false;
}
if (allCurriculums.size()!= 0) {
for(Curriculum curriculum :allCurriculums) {
if (curriculum.getCurriculumName().equals(parts[0])) {
isCurriculumExist = true;
}
}
}
if (!isCurriculumExist && isCurriculumRight) {
Curriculum curriculum;
if (parts.length == 2) {
curriculum = new Curriculum(parts[0], parts[1], "考试");
} else{
curriculum = new Curriculum(parts[0], parts[1], parts[2]);
}
allCurriculums.add(curriculum);
}
}
} else {
System.out.println("wrong format");
}
}
}
}
class DealData {
public static ArrayList<CurriculumSelection> selections = new ArrayList<>();
public static ArrayList<Student> students = new ArrayList<>();
public static void deal(ArrayList<Curriculum> allCurriculums,ArrayList<String[]> c) {
CurriculumSelection curriculumSelection;
Student student = null;
Score score = null;
int studentIndex = -1;
for(int i = 0; i < c.size(); i++) {
if (c.get(i)[0].length() == 8 && c.get(i)[1].length() < 10) {
student = new Student(c.get(i)[0],c.get(i)[1]);
}
boolean isStudentExist = false;
if (students.size()!=0 || student != null) {
for (int k = 0; k < students.size(); k++) {
if(student.getId().equals(students.get(k).getId())) {
isStudentExist = true;
studentIndex = k;
}
}
}
if(!isStudentExist && student!=null) {
students.add(student);
studentIndex ++;
}
int curriculumIndex = 0;
boolean isExist = false;
boolean isMismatch = true;
for(int j = 0; j < allCurriculums.size(); j++) {
if(c.get(i)[2].equals(allCurriculums.get(j).getCurriculumName()) ) {
isExist = true;
curriculumIndex = j;
if(c.get(i).length > 4 && allCurriculums.get(j).getAssessmentMethod().equals("考试") ) {
score = new ExamScore(Integer.parseInt(c.get(i)[3]),Integer.parseInt(c.get(i)[4]));
isMismatch = false;
}
else if(c.get(i).length == 4 && allCurriculums.get(j).getAssessmentMethod().equals("考察") ) {
score = new ExamineScore(Integer.parseInt(c.get(i)[3]));
isMismatch = false;
}
}
}
if (!isExist || isMismatch) {
score = null;
}
if (allCurriculums.size()!=0 && students.size() !=0) {
if (students.get(studentIndex)!=null) {
students.get(studentIndex).addScore(score);
curriculumSelection = new CurriculumSelection(allCurriculums.get(curriculumIndex),student,score);
allCurriculums.get(curriculumIndex).addScore(score);
selections.add(curriculumSelection);
}
}
}
}
}
class OutPut {
public static ArrayList<String> result = new ArrayList<>();
public static ArrayList<Klass> classes = new ArrayList<>();
public static void ofStudent(ArrayList<Student> students) { // 选课信息转为输出
Collections.sort(students);
for (int i = 0;i < students.size();i++) {
int score = 0; //学生的总成绩
int count = 0;
for (int j = 0; j < students.get(i).getScores().size(); j++) {
Score score1 = students.get(i).getScores().get(j);
if (score1 != null) {
score += score1.score;
count++;
}
}
if ((score != 0 && students.get(i).getScores().size() != 0) || (score == 0 && count!=0)) {
if (score!=0) {
score = score / count;
}
result.add(students.get(i).getId() + " " + students.get(i).getName() + " " + score);
} else {
result.add(students.get(i).getId() + " " + students.get(i).getName() + " did not take any exams");
}
}
}
public static void ofCurriculum(ArrayList<Curriculum> allCurriculums) {
Collections.sort(allCurriculums);
for (int i = 0; i < allCurriculums.size(); i++) {
int usualScore = 0;
int finalScore = 0;
int score = 0;
int count = 0; // 实际有的成绩数目
boolean isExam = false;
for (int j = 0; j < allCurriculums.get(i).getScores().size(); j++) {
if (allCurriculums.get(i).getAssessmentMethod().equals("考试") && allCurriculums.get(i).getScores().get(j) !=null ) {
isExam = true;
usualScore += allCurriculums.get(i).getScores().get(j).getUsualScore();
finalScore += allCurriculums.get(i).getScores().get(j).getFinalScore();
}
if (allCurriculums.get(i).getScores().get(j)!=null ) {
score += allCurriculums.get(i).getScores().get(j).getScore();
count++;
}
}
if (allCurriculums.get(i).getCurriculumName().equals("kwj")) { // 课程性质与考察方式不匹配，课程按理来说不存在
break;
} else {
if (count == 0 ) { // 课程没有成绩
result.add(allCurriculums.get(i).getCurriculumName() + " has no grades yet");
} else {
usualScore = usualScore/count;
finalScore = finalScore/count;
score = score/count;
if (isExam) { // 平时成绩 期末成绩 总成绩
result.add(allCurriculums.get(i).getCurriculumName() + " " + usualScore + " " + finalScore + " " + score);
} else {// 期末 总成绩
result.add(allCurriculums.get(i).getCurriculumName() + " " + score + " " + score);
}
}
}
}
}
public static void ofClass(ArrayList<Student> students) {
for (Student student : students) {
String classId = student.getId().substring(0, 6);
boolean isClassExist = false;
if (classes.size()!=0) {
for (Klass klass : classes) {
if (klass.getClassId().equals(classId)) {
isClassExist = true;
klass.addStudents(student);
}
}
}
if (!isClassExist) {
Klass klass = new Klass(classId);
klass.addStudents(student);
classes.add(klass);
}
}
Collections.sort(classes);
for(Klass klass : classes) {
int score = 0;
int flag = 0;
int countOfStudent = 0;
for (Student student : klass.getStudents()) {
int count = 0;
for (int j = 0; j < student.getScores().size(); j++) {
if (student.getScores().get(j) != null) {
score += student.getScores().get(j).score;
count++;
flag = 1;
}
}
if (count != 0) {
score = score / count;
countOfStudent++;
}
}
if (flag!=0) {
result.add(klass.getClassId() + " " + score / countOfStudent);
} else {
result.add(klass.getClassId() + " has no grades yet");
}
}
}
}
class Controller {
public static void Control() {
CleanData.GetAllCurriculums();
DealData.deal(CleanData.allCurriculums, CleanData.curriculumSelections);
OutPut.ofStudent(DealData.students);
OutPut.ofCurriculum(CleanData.allCurriculums);
OutPut.ofClass(DealData.students);
for(int i = 0;i<OutPut.result.size();i++) {
System.out.println(OutPut.result.get(i));
}
}
}
public class Main {
public static Scanner input = new Scanner(System.in);
public static void main(String[] args) {
Controller.Control();
}
}3.课程成绩统计程序-2：
题目分析：
课程成绩统计程序-2在第一次的基础上增加了实验课，以下加粗字体显示为本次新增的内容。实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩实验次数至少4次，不超过9次实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
这次相比与第一次主要增加的就是新的课程性质（实验课程），然后对选择实验课的选课信息进行相应的合法性检测（实验次数在规定范围内、实验的成绩与次数相等）。同时对成绩增加一个子类（实验成绩），将所有成绩存入ArrayList中。
类图：
增加了实验成绩子类，同时对成绩的输入和处理增加了实验成绩的处理
SourceMonitor分析：
对代码进行了一定的精简，程序的Avg Depth在正常范围内
完整代码：
查看代码
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Locale;
import java.util.Scanner;
class Student implements Comparable<Student>{
private String id;
private String name;
private ArrayList<Score> scores = new ArrayList<>();
public Student(String id, String name) {
this.id = id;
this.name = name;
}
public String getId() {
return id;
}
public String getName() {
return name;
}
public ArrayList<Score> getScores() {
return scores;
}
public void addScore(Score score) {
scores.add(score);
}
@Override
public int compareTo(Student student) {
return this.id.compareTo(student.id);
}
}
class Curriculum implements Comparable<Curriculum>{
private String curriculumName;
private String curriculumNature; // 课程性质
private String assessmentMethod; // 考核方式
private ArrayList<Score> scores = new ArrayList<>(); // 这门课程的全部成绩
public Curriculum(String curriculumName, String curriculumNature, String assessmentMethod) {
this.curriculumName = curriculumName;
this.curriculumNature = curriculumNature;
this.assessmentMethod = assessmentMethod;
}
public String getCurriculumName() {
return curriculumName;
}
public String getAssessmentMethod() {
return assessmentMethod;
}
public ArrayList<Score> getScores() {
return scores;
}
public void addScore(Score score) {
scores.add(score);
}
@Override
public int compareTo(Curriculum curriculum) { // 英文字母在汉字前面
return Collator.getInstance(Locale.CHINA).getCollationKey(this.curriculumName).
compareTo(Collator.getInstance(Locale.CHINA).getCollationKey(curriculum.curriculumName));
}
}
class Klass implements Comparable<Klass>{
private ArrayList<Student> students = new ArrayList<>();
private String classId;
public Klass(String classId) {
this.classId = classId;
}
public String getClassId() {
return classId;
}
public ArrayList<Student> getStudents() {
return students;
}
public void addStudents(Student student) {
this.students.add(student);
}
@Override
public int compareTo(Klass klass) {
return this.classId.compareTo(klass.classId);
}
}
abstract class Score {
protected int score;
protected boolean isLegal = true;
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public int getUsualScore() { // 让ExamScore重写该方法
return 0;
}
public int getFinalScore() {
return 0;
}
}
class ExamScore extends Score{
private int usualScore;//平时成绩
private int finalScore;//期末成绩
public ExamScore(int usualScore, int finalScore) {
this.usualScore = usualScore;
this.finalScore = finalScore;
this.score = (int)(0.3*usualScore + 0.7*finalScore);
}
public int getUsualScore() {
return this.usualScore;
}
public int getFinalScore() {
return this.finalScore;
}
}
class ExamineScore extends Score{
public ExamineScore(int score) {
this.score = score;
}
}
class ExperimentalScore extends Score {
ArrayList<Integer> scores = new ArrayList<>();
public ExperimentalScore(ArrayList<Integer> scores) {
for(Integer score : scores) {
this.score += score;
}
this.score/=scores.size();
}
}
class CurriculumSelection {
private Curriculum curriculum;
private Student student;
private Score score; // 学生这门课的成绩
public CurriculumSelection(Curriculum curriculum, Student student, Score score) {
this.curriculum = curriculum;
this.student = student;
this.score = score;
}
}
class CleanData {
public static ArrayList<Curriculum> allCurriculums = new ArrayList<>(); // 所有课程信息
public static ArrayList<String[]> curriculumSelections = new ArrayList<>(); // 所有选课信息
public static void GetAllCurriculums() {
String line;
while (!(line = Main.input.nextLine()).equals("end")) {
String[] parts = line.split("\\s+");
boolean isRight = true; // 性质是否匹配
boolean isExist = false; // 选课是否已经存在
boolean isCourseExist = false; // 课程是否已经存在
boolean isScoreRight = true; // 成绩的格式是否正确
// 选课信息
if(((parts.length <= 5 && parts.length >3) && parts[0].matches("\\d{8}") && parts[1].length() <= 10 && parts[2].length() <= 10
&& parts[3].matches("^[0-9]\\d?$|^100$")) || ( parts.length > 5 && Integer.parseInt(parts[3]) >= 4 && Integer.parseInt(parts[3]) <=9 )) {
// 判断实验课给出的成绩格式是否正确
if ( parts.length > 5 && (parts.length == Integer.parseInt(parts[3]) + 4) ) {
for (int i = 0; i < Integer.parseInt(parts[3]); i++) {
if (Integer.parseInt(parts[4 + i]) < 0 || Integer.parseInt(parts[4 + i]) > 100) {
isScoreRight = false;
}
}
}
// 判断课程性质是否匹配
for (Curriculum c : allCurriculums) {
if (c.getCurriculumName().equals(parts[2]) ) {
isCourseExist = true;
if (parts.length == 5 && c.getAssessmentMethod().equals("考试")) {
break;
} else if (parts.length == 4 && c.getAssessmentMethod().equals("考察")) {
break;
} else if (parts.length > 5 && (parts.length == Integer.parseInt(parts[3]) + 4)) {
break;
} else {
isRight = false;
parts[2] = "kwj";
}
}
}
// 选择的课程不在已有课程中
if (!isCourseExist && isScoreRight) {
System.out.println(parts[2] + " does not exist");
}
// 选课的成绩出现格式错误
if (!isScoreRight) {
System.out.println("wrong format");
}
// 课程性质与考核方式不匹配
if (!isRight) {
System.out.println(parts[0] + " " +parts[1] + " " + ":" + " access mode mismatch");
}
// 判断选课信息是否已经存在
if (curriculumSelections.size()!=0) {
for(String[] s:curriculumSelections) {
if (s[0].equals(parts[0]) && s[2].equals(parts[2]) && !s[2].equals("kwj") ) {
isExist = true;
}
}
}
// 添加选课信息
if ( !isExist && isScoreRight) {
curriculumSelections.add(parts);
} else if (!isRight || isExist || !isScoreRight) {
} else {
System.out.println("wrong format");
}
}
// 课程信息
else if ((parts.length == 2 || parts.length ==3) && !parts[0].matches("\\d+") ) {
// 课程性质是否与考核方式匹配
if(parts.length == 3 && parts[1].equals("必修") && parts[2].equals("考察") ) {
System.out.println( parts[0] + " : course type & access mode mismatch");
} else if (parts.length == 3 && ((parts[1].equals("实验") && !parts[2].equals("实验")) || (!parts[1].equals("实验") && parts[2].equals("实验")))) {
System.out.println(parts[0] + " : course type & access mode mismatch");
}
// 匹配后进行格式等其他方面的判断
else {
boolean isCurriculumExist = false;
boolean isCurriculumRight = true;
// 其他选择是否为正确的
if (parts.length == 3 && (parts[0].length() > 10 || (!parts[1].equals("必修") && !parts[1].equals("选修") && !parts[1].equals("实验")) ||
(!parts[2].equals("考试") && !parts[2].equals("考察") && !parts[2].equals("实验"))) ) {
System.out.println("wrong format");
isCurriculumRight = false;
}
if (parts.length == 2 && parts[1].equals("选修")) {
System.out.println("wrong format");
isCurriculumRight = false;
}
// 判断课程是否存在
if (allCurriculums.size()!= 0) {
for(Curriculum curriculum :allCurriculums) {
if (curriculum.getCurriculumName().equals(parts[0])) {
isCurriculumExist = true;
}
}
}
// 添加课程
if (!isCurriculumExist && isCurriculumRight) {
Curriculum curriculum;
if (parts.length == 2) {
curriculum = new Curriculum(parts[0], parts[1], "考试");
} else{
curriculum = new Curriculum(parts[0], parts[1], parts[2]);
}
allCurriculums.add(curriculum);
}
}
}
// 输入的格式存在错误，不进行储存
else {
System.out.println("wrong format");
}
}
}
}
class DealData {
public static ArrayList<CurriculumSelection> selections = new ArrayList<>(); // 所有正确的选课信息
public static ArrayList<Student> students = new ArrayList<>(); // 学生列表
public static void deal(ArrayList<Curriculum> allCurriculums,ArrayList<String[]> c) {
CurriculumSelection curriculumSelection;
Student student = null;
Score score = null;
int studentIndex = -1;
for(int i = 0; i < c.size(); i++) { // 根据选课列表创建学生
if (c.get(i)[0].length() == 8 && c.get(i)[1].length() < 10) {
student = new Student(c.get(i)[0],c.get(i)[1]);
}
boolean isStudentExist = false;
// 学生是否已经存在
if (students.size()!=0 || student != null) {
for (int k = 0; k < students.size(); k++) {
if(student.getId().equals(students.get(k).getId())) {
isStudentExist = true;
studentIndex = k;
}
}
}
if(!isStudentExist && student!=null) {
students.add(student);
studentIndex ++;
}
int curriculumIndex = 0;
boolean isExist = false;
boolean isMismatch = true;
// 选择的课程是否存在
for(int j = 0; j < allCurriculums.size(); j++) {
if(c.get(i)[2].equals(allCurriculums.get(j).getCurriculumName()) ) {
isExist = true;
curriculumIndex = j;
// 考核方式是否匹配
if(c.get(i).length == 5 && allCurriculums.get(j).getAssessmentMethod().equals("考试") ) {
score = new ExamScore(Integer.parseInt(c.get(i)[3]),Integer.parseInt(c.get(i)[4]));
isMismatch = false;
}
else if(c.get(i).length == 4 && allCurriculums.get(j).getAssessmentMethod().equals("考察") ) {
score = new ExamineScore(Integer.parseInt(c.get(i)[3]));
isMismatch = false;
} else if (c.get(i).length > 5) {
ArrayList<Integer> scores = new ArrayList<>();
for (int k = 0 ;k < Integer.parseInt(c.get(i)[3]); k++) {
scores.add(Integer.parseInt(c.get(i)[4+k]));
}
score = new ExperimentalScore(scores);
isMismatch = false;
}
}
}
if (!isExist || isMismatch) {
score = null;
}
// 都正确的情况下创建选课信息
if (allCurriculums.size()!=0 && students.size() !=0) {
if (students.get(studentIndex)!=null) {
students.get(studentIndex).addScore(score);
curriculumSelection = new CurriculumSelection(allCurriculums.get(curriculumIndex),student,score);
allCurriculums.get(curriculumIndex).addScore(score);
selections.add(curriculumSelection);
}
}
}
}
}
class OutPut {
public static ArrayList<String> result = new ArrayList<>();
public static ArrayList<Klass> classes = new ArrayList<>();
// 输出学生的成绩
public static void ofStudent(ArrayList<Student> students) {
Collections.sort(students);
for (Student student : students) {
int score = 0; //学生的总成绩
int count = 0;
for (int j = 0; j < student.getScores().size(); j++) {
Score score1 = student.getScores().get(j);
if (score1 != null) {
score += score1.score;
count++;
}
}
if ((score != 0 && student.getScores().size() != 0) || (score == 0 && count != 0)) {
if (score != 0) {
score = score / count;
}
result.add(student.getId() + " " + student.getName() + " " + score);
} else {
result.add(student.getId() + " " + student.getName() + " did not take any exams");
}
}
}
// 输出课程成绩
public static void ofCurriculum(ArrayList<Curriculum> allCurriculums) {
Collections.sort(allCurriculums);
for (Curriculum allCurriculum : allCurriculums) {
int usualScore = 0; // 考试的平时成绩
int finalScore = 0; // 考试的期末成绩
int score = 0; // 总成绩
int count = 0; // 实际有的成绩数目
boolean isExam = false;
for (int j = 0; j < allCurriculum.getScores().size(); j++) {
if (allCurriculum.getAssessmentMethod().equals("考试") && allCurriculum.getScores().get(j) != null) {
isExam = true;
usualScore += allCurriculum.getScores().get(j).getUsualScore();
finalScore += allCurriculum.getScores().get(j).getFinalScore();
}
if (allCurriculum.getScores().get(j) != null) {
score += allCurriculum.getScores().get(j).getScore();
count++;
}
}
if (allCurriculum.getCurriculumName().equals("kwj")) { // 课程性质与考察方式不匹配，课程按理来说不存在
break;
} else {
if (count == 0) { // 课程没有成绩
result.add(allCurriculum.getCurriculumName() + " has no grades yet");
} else {
usualScore = usualScore / count;
finalScore = finalScore / count;
score = score / count;
// 实验课成绩 只输出实验成绩的平均分
if (allCurriculum.getAssessmentMethod().equals("实验")) {
result.add(allCurriculum.getCurriculumName() + " " + score);
} else {
if (isExam) { // 平时成绩 期末成绩 总成绩
result.add(allCurriculum.getCurriculumName() + " " + usualScore + " " + finalScore + " " + score);
} else {// 期末 总成绩
result.add(allCurriculum.getCurriculumName() + " " + score + " " + score);
}
}
}
}
}
}
// 输出班级的平均成绩
public static void ofClass(ArrayList<Student> students) {
// 通过学生学号的前6位创建班级
for (Student student : students) {
String classId = student.getId().substring(0, 6);
boolean isClassExist = false;
if (classes.size()!=0) {
for (Klass klass : classes) {
if (klass.getClassId().equals(classId)) {
isClassExist = true;
klass.addStudents(student);
}
}
}
if (!isClassExist) {
Klass klass = new Klass(classId);
klass.addStudents(student);
classes.add(klass);
}
}
Collections.sort(classes);
// 遍历班级及班级的学生进行平均成绩的输出
for(Klass klass : classes) {
int score = 0;
int flag = 0;
int countOfStudent = 0;
for (Student student : klass.getStudents()) {
int count = 0;
for (int j = 0; j < student.getScores().size(); j++) {
if (student.getScores().get(j) != null) {
score += student.getScores().get(j).score;
count++;
flag = 1;
}
}
if (count != 0) {
score = score / count;
countOfStudent++;
}
}
if (flag!=0) {
result.add(klass.getClassId() + " " + score / countOfStudent);
} else {
result.add(klass.getClassId() + " has no grades yet");
}
}
}
}
class Controller {
public static void Control() {
CleanData.GetAllCurriculums();
DealData.deal(CleanData.allCurriculums, CleanData.curriculumSelections);
OutPut.ofStudent(DealData.students);
OutPut.ofCurriculum(CleanData.allCurriculums);
OutPut.ofClass(DealData.students);
for(int i = 0;i<OutPut.result.size();i++) {
System.out.println(OutPut.result.get(i));
}
}
}
public class Main {
public static Scanner input = new Scanner(System.in);
public static void main(String[] args) {
Controller.Control();
}
}4.课程成绩统计程序-3：
题目分析：
要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。
这次相较于之前最大的变化就是成绩的结构，运用组合关系的话，我把之前的子类都整合在一个类中（分项成绩类），然后把分项成绩组合在成绩中，改写成绩类的计算成绩的方法；因为这会成绩的计算与权重相关，所以我把成绩和权重分开存在两个ArrayList中（分项成绩中的两个属性）。
涉及到成绩与权重的计算，精度问题必须要进行相应的考虑。
类图：
总体结构与之前没有太大改变，主要是修改了成绩之间的关系
SourceMonitor分析：
一个方法中的代码写得过于复杂，没有进行相应的拆分，所用到的分支嵌套也比较多，所以Avg Depth（函数平均深度）等过大，不在良好的范围内。
完整代码：
查看代码
import java.text.Collator;
import java.util.*;
class Student implements Comparable<Student>{
private String id;
private String name;
private ArrayList<Score> scores = new ArrayList<>();
public Student(String id, String name) {
this.id = id;
this.name = name;
}
public String getId() {
return id;
}
public String getName() {
return name;
}
public ArrayList<Score> getScores() {
return scores;
}
public void addScore(Score score) {
scores.add(score);
}
@Override
public int compareTo(Student student) {
return this.id.compareTo(student.id);
}
}
class Curriculum implements Comparable<Curriculum> {
private String curriculumName;
private String curriculumNature; // 课程性质
private String assessmentMethod; // 考核方式
private ArrayList<Float> weight = new ArrayList<>();
private ArrayList<Score> scores = new ArrayList<>(); // 这门课程的全部成绩
public ArrayList<Float> getWeight() {
return weight;
}
public void setWeight(ArrayList<Float> weight) {
this.weight = weight;
}
public Curriculum(String curriculumName, String curriculumNature, String assessmentMethod) {
this.curriculumName = curriculumName;
this.curriculumNature = curriculumNature;
this.assessmentMethod = assessmentMethod;
}
public String getCurriculumName() {
return curriculumName;
}
public String getAssessmentMethod() {
return assessmentMethod;
}
public ArrayList<Score> getScores() {
return scores;
}
public void addScore(Score score) {
scores.add(score);
}
@Override
public int compareTo(Curriculum curriculum) { // 字符顺序
return this.curriculumName.compareTo(curriculum.curriculumName);
}
}
class Klass implements Comparable<Klass>{
private ArrayList<Student> students = new ArrayList<>();
private String classId;
public Klass(String classId) {
this.classId = classId;
}
public String getClassId() {
return classId;
}
public ArrayList<Student> getStudents() {
return students;
}
public void addStudents(Student student) {
this.students.add(student);
}
@Override
public int compareTo(Klass klass) {
return this.classId.compareTo(klass.classId);
}
}
class Score {
public int score;
public ItemScore itemScore;
protected boolean isLegal = true;
public Score(ItemScore itemScore) {
this.itemScore = itemScore;
}
public int getScore() {
float score = 0;
int count = 0;
if (itemScore.scores.size() == 1) {
return itemScore.scores.get(0);
} else{
for (Integer score1 : itemScore.scores) {
score += score1 * itemScore.weight.get(count);
count++;
}
return (int)score;
}
}
}
class ItemScore {
public ArrayList<Integer> scores = new ArrayList<>();
public ArrayList<Float> weight = new ArrayList<>();
public ItemScore(ArrayList<Integer> scores, ArrayList<Float> weight) {
this.scores = scores;
this.weight = weight;
}
}
class CurriculumSelection {
private Curriculum curriculum;
private Student student;
private Score score; // 学生这门课的成绩
public CurriculumSelection(Curriculum curriculum, Student student, Score score) {
this.curriculum = curriculum;
this.student = student;
this.score = score;
}
}
class CleanData {
public static ArrayList<Curriculum> allCurriculums = new ArrayList<>(); // 所有课程信息
public static ArrayList<String[]> curriculumSelections = new ArrayList<>(); // 所有选课信息
public static void GetAllCurriculums() {
String line;
while (!(line = Main.input.nextLine()).equals("end")) {
String[] parts = line.split("\\s+");
boolean isRight = true; // 性质是否匹配
boolean isExist = false; // 选课是否已经存在
boolean isCourseExist = false; // 课程是否已经存在
boolean isScoreRight = true; // 成绩的格式是否正确
// 选课信息
if(parts.length <= 12 && parts.length > 3 && parts[0].matches("\\d{8}") && parts[1].length() <= 10 && parts[2].length() <= 10
&& parts[3].matches("^[0-9]\\d?$|^100$") ) {
// 判断课程性质是否匹配
for (Curriculum c : allCurriculums) {
if (c.getCurriculumName().equals(parts[2]) ) {
isCourseExist = true;
// 判断实验课给出的成绩格式是否正确
if ( parts.length > 5 && (parts.length == c.getWeight().size() + 3) ) {
for (int i = 0; i < c.getWeight().size(); i++) {
if (Integer.parseInt(parts[3 + i]) < 0 || Integer.parseInt(parts[3 + i]) > 100) {
System.out.println("wrong format");
isScoreRight = false;
}
}
break;
}
if (parts.length == 5 && c.getAssessmentMethod().equals("考试")) {
break;
} else if (parts.length == 4 && c.getAssessmentMethod().equals("考察")) {
break;
} else {
isRight = false;
parts[2] = "kwj";
}
}
}
// 选择的课程不在已有课程中
if (!isCourseExist) {
System.out.println(parts[2] + " does not exist");
}
// 课程性质与考核方式不匹配
if (!isRight && isCourseExist) {
System.out.println(parts[0] + " " +parts[1] + " " + ":" + " access mode mismatch");
}
// 判断选课信息是否已经存在
if (curriculumSelections.size()!=0) {
for(String[] s:curriculumSelections) {
if (s[0].equals(parts[0]) && s[2].equals(parts[2]) && !s[2].equals("kwj") ) {
isExist = true;
}
}
}
// 添加选课信息
if ( !isExist && isScoreRight) {
curriculumSelections.add(parts);
}
}
// 课程信息
else if ((parts.length > 2 || parts.length < 13) && !parts[0].matches("\\d{8}") ) {
// 课程性质是否与考核方式匹配
if(parts.length == 3 && parts[1].equals("必修") && parts[2].equals("考察") ) {
System.out.println( parts[0] + " : course type & access mode mismatch");
} else if (parts.length >= 3 && ((parts[1].equals("实验") && !parts[2].equals("实验")) || (!parts[1].equals("实验") && parts[2].equals("实验")))) {
System.out.println(parts[0] + " : course type & access mode mismatch");
} else if (parts.length == 5 && (!parts[1].equals("必修")|| !parts[2].equals("考试")) && !parts[2].equals("实验")) {
System.out.println(parts[0] + " : course type & access mode mismatch");
}
// 匹配后进行格式等其他方面的判断
else {
boolean isCurriculumExist = false;
boolean isCurriculumRight = true;
// 其他选择是否为正确的
if (parts.length == 3 && (parts[0].length() > 10 || (!parts[1].equals("必修") && !parts[1].equals("选修") && !parts[1].equals("实验")) ||
(!parts[2].equals("考试") && !parts[2].equals("考察") && !parts[2].equals("实验"))) ) {
System.out.println("wrong format");
isCurriculumRight = false;
}
if (parts.length == 2 && parts[1].equals("选修")) {
System.out.println("wrong format");
isCurriculumRight = false;
}
if (parts.length >= 5 && parts[3].matches("\\d+") ) { // 实验课程
if (Integer.parseInt(parts[3]) > 9 || Integer.parseInt(parts[3]) < 4) {
System.out.println("wrong format");
isCurriculumRight = false;
} else if ( Integer.parseInt(parts[3]) + 4 != parts.length ) {
System.out.println(parts[0] + " : number of scores does not match");
isCurriculumRight = false;
}
}
// 判断课程是否存在
if (allCurriculums.size()!= 0) {
for(Curriculum curriculum :allCurriculums) {
if (curriculum.getCurriculumName().equals(parts[0])) {
isCurriculumExist = true;
}
}
}
// 添加课程
if (!isCurriculumExist && isCurriculumRight) {
Curriculum curriculum;
ArrayList<Float> weightOfExam = new ArrayList<>();
if (parts.length > 5 ) { // 实验
float sum = 0;
ArrayList<Float> weight = new ArrayList<>();
for (int i = 0; i < Integer.parseInt(parts[3]); i++) {
sum += Float.parseFloat(parts[4 + i]);
weight.add(Float.parseFloat(parts[4 + i]));
}
if (sum < 0.99 || sum > 1.01) {
System.out.println(parts[0] + " : weight value error");
}
else {
curriculum = new Curriculum(parts[0], parts[1], parts[2]);
curriculum.setWeight(weight);
allCurriculums.add(curriculum);
}
}
else if (parts[2].equals("考试") && parts[1].equals("必修")) {
float sum = Float.parseFloat(parts[3]) + Float.parseFloat(parts[4]);
if ( sum < 0.99 || sum > 1.01) {
System.out.println(parts[0] + " : weight value error");
}
else {
curriculum = new Curriculum(parts[0], parts[1], parts[2]);
weightOfExam.add(Float.parseFloat(parts[3]));
weightOfExam.add(Float.parseFloat(parts[4]));
curriculum.setWeight(weightOfExam);
allCurriculums.add(curriculum);
}
} else {
curriculum = new Curriculum(parts[0], parts[1], parts[2]);
allCurriculums.add(curriculum);
}
}
}
}
// 输入的格式存在错误，不进行储存
else {
System.out.println("wrong format");
}
}
}
}
class DealData {
public static ArrayList<CurriculumSelection> selections = new ArrayList<>(); // 所有正确的选课信息
public static ArrayList<Student> students = new ArrayList<>(); // 学生列表
public static void deal(ArrayList<Curriculum> allCurriculums,ArrayList<String[]> c) {
CurriculumSelection curriculumSelection;
Student student = null;
Score score = null;
int studentIndex = -1;
for(int i = 0; i < c.size(); i++) { // 根据选课列表创建学生
if (c.get(i)[0].length() == 8 && c.get(i)[1].length() < 10) {
student = new Student(c.get(i)[0],c.get(i)[1]);
}
boolean isStudentExist = false;
// 学生是否已经存在
if (students.size()!=0 || student != null) {
for (int k = 0; k < students.size(); k++) {
if(student.getId().equals(students.get(k).getId())) {
isStudentExist = true;
studentIndex = k;
}
}
}
if(!isStudentExist && student!=null) {
students.add(student);
studentIndex ++;
}
int curriculumIndex = 0;
boolean isExist = false;
boolean isMismatch = true;
ArrayList<Integer> scores = new ArrayList<>();
// 选择的课程是否存在
for(int j = 0; j < allCurriculums.size(); j++) {
if(c.get(i)[2].equals(allCurriculums.get(j).getCurriculumName()) ) {
isExist = true;
curriculumIndex = j;
Curriculum c1 = allCurriculums.get(j);
// 考核方式是否匹配
if(c.get(i).length == 5 && c1.getAssessmentMethod().equals("考试") ) {
scores.add(Integer.parseInt(c.get(i)[3]));
scores.add(Integer.parseInt(c.get(i)[4]));
ItemScore itemScore = new ItemScore(scores,c1.getWeight());
score = new Score(itemScore);
isMismatch = false;
}
else if(c.get(i).length == 4 && c1.getAssessmentMethod().equals("考察") ) {
scores.add(Integer.parseInt(c.get(i)[3]));
score = new Score(new ItemScore(scores, c1.getWeight()));
isMismatch = false;
} else if (c.get(i).length > 5) {
for (int k = 0 ;k < allCurriculums.get(j).getWeight().size(); k++) {
scores.add(Integer.parseInt(c.get(i)[3+k]));
}
score = new Score(new ItemScore(scores,c1.getWeight()));
isMismatch = false;
}
}
}
if (!isExist || isMismatch) {
score = null;
}
// 都正确的情况下创建选课信息
if (allCurriculums.size()!=0 && students.size() !=0) {
if (students.get(studentIndex)!=null) {
students.get(studentIndex).addScore(score);
curriculumSelection = new CurriculumSelection(allCurriculums.get(curriculumIndex),student,score);
allCurriculums.get(curriculumIndex).addScore(score);
selections.add(curriculumSelection);
}
}
}
}
}
class OutPut {
public static ArrayList<String> result = new ArrayList<>();
public static ArrayList<Klass> classes = new ArrayList<>();
// 输出学生的成绩
public static void ofStudent(ArrayList<Student> students) {
Collections.sort(students);
for (Student student : students) {
int score = 0; //学生的总成绩
int count = 0;
for (int j = 0; j < student.getScores().size(); j++) {
Score score1 = student.getScores().get(j);
if (score1 != null) {
score += score1.getScore();
count++;
}
}
if ((score != 0 && student.getScores().size() != 0) || (score == 0 && count != 0)) {
if (score != 0) {
score = score / count;
}
result.add(student.getId() + " " + student.getName() + " " + score);
} else {
result.add(student.getId() + " " + student.getName() + " did not take any exams");
}
}
}
// 输出课程成绩
public static void ofCurriculum(ArrayList<Curriculum> allCurriculums) {
Collections.sort(allCurriculums);
for (Curriculum allCurriculum : allCurriculums) {
int score = 0; // 总成绩
int count = 0; // 实际有的成绩数目
for (int j = 0; j < allCurriculum.getScores().size(); j++) {
if (allCurriculum.getScores().get(j) != null) {
score += allCurriculum.getScores().get(j).getScore();
count++;
}
}
if (allCurriculum.getCurriculumName().equals("kwj")) { // 课程性质与考察方式不匹配，课程按理来说不存在
break;
} else {
if (count == 0) { // 课程没有成绩
result.add(allCurriculum.getCurriculumName() + " has no grades yet");
} else {
score = score / count;
// 实验课成绩 只输出实验成绩的平均分
result.add(allCurriculum.getCurriculumName() + " " + score);
}
}
}
}
// 输出班级的平均成绩
public static void ofClass(ArrayList<Student> students) {
// 通过学生学号的前6位创建班级
for (Student student : students) {
String classId = student.getId().substring(0, 6);
boolean isClassExist = false;
if (classes.size()!=0) {
for (Klass klass : classes) {
if (klass.getClassId().equals(classId)) {
isClassExist = true;
klass.addStudents(student);
}
}
}
if (!isClassExist) {
Klass klass = new Klass(classId);
klass.addStudents(student);
classes.add(klass);
}
}
Collections.sort(classes);
// 遍历班级及班级的学生进行平均成绩的输出
for(Klass klass : classes) {
int score = 0;
int flag = 0;
int countOfStudent = 0;
for (Student student : klass.getStudents()) {
int count = 0;
for (int j = 0; j < student.getScores().size(); j++) {
if (student.getScores().get(j) != null) {
score += student.getScores().get(j).getScore();
count++;
flag = 1;
}
}
if (count != 0) {
score = score / count;
countOfStudent++;
}
}
if (flag!=0) {
result.add(klass.getClassId() + " " + score / countOfStudent);
} else {
result.add(klass.getClassId() + " has no grades yet");
}
}
}
}
class Controller {
public static void Control() {
CleanData.GetAllCurriculums();
DealData.deal(CleanData.allCurriculums, CleanData.curriculumSelections);
OutPut.ofStudent(DealData.students);
OutPut.ofCurriculum(CleanData.allCurriculums);
OutPut.ofClass(DealData.students);
for(int i = 0;i<OutPut.result.size();i++) {
System.out.println(OutPut.result.get(i));
}
}
}
public class Main {
public static Scanner input = new Scanner(System.in);
public static void main(String[] args) {
Controller.Control();
}
}踩坑心得：
1.在关键字统计中一开始的思路是用contain来判断一行中是否有这个关键字，但没有考虑到重复出现的情况，并且contain跟equal还是有很大区别的，应该把一个个代码词拿出来与关键字进行equal的比较。这样导致我第一次提交只有特殊案例有正常的输出。
2.还是关键词统计中的一个坑，运算符和一些其他特殊符号与关键词结合在一起，这个关键词不应该被统计
3.在选课1中，一开始考虑到的格式错误情况只有题目及案例给的一些，没有考虑到输入的不是正常的选择（课程性质不是必修或选修），课程信息长度不规范等一些其他的错误，导致很多格式错误的案例没有过
4.选课时单门考察成绩，如果那个人成绩就是0分，应该是输出0，而不是没有参加考试，这个是我判断时没有考虑到
5.选课3中由于成绩的计算改为了成绩*权重，所以要特别注意精度，double的精度很大，在四舍五入取整时就会出现精度差的问题，因为我一开始使用的都是double类型，所以吃了很大的亏，基本上只对了样例
6.权重值是否为1的判断，不可以直接与1比，要相应的进行小范围的进度扩大
改进建议：
1.从刚开始学习就很强调编码的规范性，但是在单一职责方面还是很难做好，一个方法为了达到效果写得很杂，成绩统计的三次迭代，每次都在原本很乱的代码上进行增加，没有很好地拆分，减少方法中的代码长度。可以把读取数据中对数据的正确性检验按照不同的错误方式写相应的方法，而不是一股脑的扔进读取方法中；
2.在统计字符串中使用了正则表达式，代码比较简洁，在成绩统计中对读取到的成绩可以用正则表达式来判断是否在规定范围，是否为数字，正则表达式是很好用的一个工具。
总结：
1.最后一阶段的学习主要是针对集合框架体系，让我们对集合，队列，图有一定的了解，学会合理地去使用，为之后的课程打下一定的基础。但是对于这些工具的使用还不是很熟练，很多时候都要去网上进行查询，要加深对集合框架体系的学习；
2.对于组合和继承，组合减少了类与类之间的耦合，继承创建了一个紧密的耦合关系，子类与父类之间紧密地绑定在一起，而组合更加灵活，同时组合可以可以根据需要添加、删除或替换组成的类，而不会对整个代码结构造成太大的影响；
3.随着学习的推进，写题目更多的是要规范编码，满足必要的要求，转变自己的思想，不要怕类多，设计要满足单一职责，同时合理利用MVC减少主函数的职责；
4.每次题目集的设计比较合理，有对之前学习的类的继承，多态，类之间的组合和类的基本知识的复习又有这一阶段学习的容器的巩固练习；
课程评价：
1.教学理念（OBE）：
在强调学习成果关注学生在课程结束时所能够达到的具体学习成果上，把课堂上的知识转化到题目集及一些任务（雨刷器的迭代）上，帮助我们在课程中获得实际的知识，而不仅仅是通过记忆和理解概念（不用死记硬背）；
在对学生学习成果的评估和反馈上做的不是很好，课上开头，课后要求我们自主去深入学习，但是很多时候我们不会过多地系统去学习，而是对我们要用上的东西进行相应的了解。而且老师对我们学习的情况了解的不确切，学生反馈的情况不是很好。
2.教学方法（边讲边练）：
通过边讲边练的教学方法，我们可以把课堂上学习到的理论知识进行实践操作，加深对知识的理解和记忆，提高学习效果。同时帮助我们培养编程能力和实际应用能力。
3.教学组织（线上线下混合式教学）：
线上慕课的学习，很大程度上大家是抱着刷课的心态去观看的，实际上对线上课程的内容了解不是很深入，线上教学在混合式教学起到的作用不是很大。
4.教学过程（PTA题目集驱动）：
PTA题目集驱动的教学过程注重实践操作，我们可以通过解决具体的编程问题来巩固和应用所学的知识。有助于加深我们对面向对象编程和java语言的理解。每次题目集的设计比较合理，涵盖了我们阶段性学习的知识点，同时按照学习过程来布置每一次的PTA，让我们有系统性的练习。
5.教学模式（BOPPPS)：
BBOPPS的教学模式更多的需要老师和学生之间的一个互动，老师上课为我们开个头，引导我们去学习，同时注重我们对课程的主动参与，像上课动手解决老师布置的任务等都是很好的一个示范；每次的Blog作业就是对阶段性学习的一个总结；
在课后总结（Summary)上布置的还行，但课前评估（Pre-assessment）上可以增加更为多样的评估方式，了解我们对所学内容的预习程度。
浙公网安备 33010602011771号