作业总结
第六次作业总结
1.前言
本次作业是进行学生成绩统计的程序设计，它设计考察学生以及班级的课程成绩，对于不同课程性质的课程有不同的考察方式，所以对于不同课程性质的课程需要进行判断，比如必修必须是考试的考察方式而选修就可以是考试和考察都可以进行选择。对于错误数据的问题也需要注意，比如出现重复课程和课程成绩只将第一个数据进行录入，后面的数据不进行录入。输出时也需要注意按照学号从高到低的顺序进行输出。
2.设计与分析
1.分析
需要注意相同班级的学生学号前几位是相同的，成绩的平均分是按照所有学生的总分数除以学生的人数来判断，同时对于课程，成绩，学生，班级之间需要以一个选课的系统来联系在一起，信息同样进行约束，对于学号需要设置为8位数，同样对于成绩需要进行取整，保留四舍五入。
2.设计
使用text中SimpleDateFormat来自定义输入日期的格式，dateTime.getDay() 获取星期几（0表示周日，1表示周一，2表示周二，以此类推）
使用HashMap来保存table的数据，通过equals（）来判断输入
3.采坑心得
import java.util.*;
public class Main {
static class Course {
String name;
String type; // 必修 or 选修
String mode; // 考试 or 考察
public Course(String name, String type, String mode) {
this.name = name;
this.type = type;
this.mode = mode;
}
}
static class StudentGrade {
String id;
String name;
String courseName;
int regularScore; // 平时成绩
int finalScore; // 期末成绩
int totalScore; // 总成绩
boolean validGrade; // 新增属性，标记该成绩是否有效
public StudentGrade(String id, String name, String courseName, int regularScore, int finalScore, int totalScore, boolean validGrade) {
this.id = id;
this.name = name;
this.courseName = courseName;
this.regularScore = regularScore;
this.finalScore = finalScore;
this.totalScore = totalScore;
this.validGrade = validGrade;
}
}
private static LinkedHashMap<String, Course> courses = new LinkedHashMap<>();
private static TreeMap<String, List<StudentGrade>> students = new TreeMap<>();
private static TreeMap<String, List<StudentGrade>> classes = new TreeMap<>();
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
if (line.equals("end")) break;
String[] parts = line.split(" ");
if (parts.length == 3) {
parseCourse(parts);
} else {
parseStudentGrade(parts);
}
}
printAverageGrades();
}
private static void parseCourse(String[] parts) {
if (parts[1].equals("必修") && parts[2].equals("考察")) {
System.out.println(parts[0] + " : course type & access mode mismatch");
return;
}
Course course = new Course(parts[0], parts[1], parts[2]);
courses.put(course.name, course);
}
private static void parseStudentGrade(String[] parts) {
if (!courses.containsKey(parts[2])) {
System.out.println(parts[2] + " does not exist");
System.out.println(parts[0].substring(0, 8)+ " "+parts[1] + " did not take any exams"); // Add this line
System.out.println(parts[0].substring(0, 6) + " has no grades yet"); // Add this line
return;
}
Course course = courses.get(parts[2]);
int regularScore = 0, finalScore = 0, totalScore = 0;
boolean validGrade = true;
if (parts.length == 5) {
if (!course.mode.equals("考试")) {
System.out.println(parts[0] + " " + parts[1] + " : access mode mismatch");
validGrade = false;
} else {
regularScore = Integer.parseInt(parts[3]);
finalScore = Integer.parseInt(parts[4]);
if (regularScore < 0 || regularScore > 100 || finalScore < 0 || finalScore > 100) {
System.out.println("wrong format");
validGrade = false;
} else {
totalScore = (int) (0.3 * regularScore + 0.7 * finalScore);
}
}
} else if (parts.length == 4) {
if (course.mode.equals("考试")) {
System.out.println(parts[0] + " " + parts[1] + " : access mode mismatch");
validGrade = false;
} else {
finalScore = Integer.parseInt(parts[3]);
if (finalScore < 0 || finalScore > 100) {
System.out.println("wrong format");
validGrade = false;
} else {
totalScore = finalScore;
}
}
}
StudentGrade grade = new StudentGrade(parts[0], parts[1], parts[2], regularScore, finalScore, totalScore, validGrade);
students.computeIfAbsent(parts[0] + " " + parts[1], k -> new ArrayList<>()).add(grade);
classes.computeIfAbsent(parts[0].substring(0, 6), k -> new ArrayList<>()).add(grade);
}
private static void printAverageGrades() {
// Print student average grades.
for (Map.Entry<String, List<StudentGrade>> entry : students.entrySet()) {
String student = entry.getKey();
List<StudentGrade> grades = entry.getValue();
int sum = 0;
int validCount = 0;
for (StudentGrade grade : grades) {
if (grade.validGrade) {
sum += grade.totalScore;
validCount++;
}
}
if (validCount > 0) { // Print only if there is a valid grade
System.out.println(student + " " + sum / validCount);
}
}
// Create a priority queue to store the course average grades in ascending order.
PriorityQueue<Map.Entry<String, Integer>> pq = new PriorityQueue<>(
Map.Entry.<String, Integer>comparingByValue());
// Calculate course average grades.
for (String courseName : courses.keySet()) {
Course course = courses.get(courseName);
List<StudentGrade> courseGrades = getCourseGrades(courseName);
if (courseGrades.isEmpty()) {
System.out.println(courseName + " has no grades yet");
continue;
}
int regularSum = 0, finalSum = 0, totalSum = 0;
for (StudentGrade grade : courseGrades) {
regularSum += grade.regularScore;
finalSum += grade.finalScore;
totalSum += grade.totalScore;
}
int averageTotalScore = totalSum / courseGrades.size();
pq.offer(new AbstractMap.SimpleEntry<>(courseName, averageTotalScore));
}
// Print course average grades in ascending order of total score.
while (!pq.isEmpty()) {
Map.Entry<String, Integer> entry = pq.poll();
String courseName = entry.getKey();
List<StudentGrade> courseGrades = getCourseGrades(courseName);
Course course = courses.get(courseName);
int regularSum = 0, finalSum = 0, totalSum = 0;
for (StudentGrade grade : courseGrades) {
regularSum += grade.regularScore;
finalSum += grade.finalScore;
totalSum += grade.totalScore;
}
if (course.mode.equals("考试")) {
System.out.println(courseName + " " + regularSum / courseGrades.size() + " " + finalSum / courseGrades.size() + " " + totalSum / courseGrades.size());
} else {
System.out.println(courseName + " " + finalSum / courseGrades.size() + " " + totalSum / courseGrades.size());
}
}
// Print class average grades.
for (Map.Entry<String, List<StudentGrade>> entry : classes.entrySet()) {
String classId = entry.getKey();
List<StudentGrade> grades = entry.getValue();
int sum = 0;
int validCount = 0;
for (StudentGrade grade : grades) {
if (grade.validGrade) {
sum += grade.totalScore;
validCount++;
}
}
if (validCount > 0) { // Print only if there is a valid grade
System.out.println(classId + " " + sum / validCount);
}
}
}
private static List<StudentGrade> getCourseGrades(String courseName) {
List<StudentGrade> courseGrades = new ArrayList<>();
for (List<StudentGrade> grades : students.values()) {
for (StudentGrade grade : grades) {
if (grade.courseName.equals(courseName) && grade.validGrade) {
courseGrades.add(grade);
}
}
}
return courseGrades;
}
}
对于班级的存储出现了多个班级存储时班级的成员无法将数据存入等情况。
对于出现错误时错误的课程信息以及错误的成绩信息出现了非零返回的错误
对于重复出现的数据没有及进行只将第一个输入的数据存入，导致后面输入的数据取代了前面的数据从而出现了错误。
对于单门课程，多个班级，含错误信息时，程序在检测出错误后直接输出了错误后后面的数据没有继续进行。
4.主要困难以及改进意见
1.困难
本次作业所需要学习并且了解util库中所包含的方法和种类，同时还要求设置不同错误所包含的点，并且还需要设置学号的标准格式。
作业中所设计的混合错误以及多个班级同时进行的功能需要进行设计，这使得需要设计一个Map来保存class中数据的存储
同时还需要设计其他的类来组合完成所添加的功能，而类与类之间的关联还需要进行进一步的设计和思考
2.改进意见
可以减少程序中静态导入滥用静态导入会使程序更难阅读，更难维护。静态导入后，代码中就不用再写类名了，但是我们知道类是“一类事物的描述”，缺少了类名的修饰，静态属性和静态方法的表象意义可以被无限放大，这会让阅读者很难弄清楚所谓何意。
避免在构造函数中初始化其他类更符合面向对象编程类与类关系复杂，容易造成栈溢出
第七次作业总结
1.前言
本次作业是在第六次作业的基础上添加了新的功能，本次作业需要对于第三次作业有一定的理解才能进行和完成
本次作业是作业六的一个迭代，本次作业增加了实验课程的课程性质，同时对于实验课它自己有独特的考核方式
实验课具有实验次数，试验次数是不少于4次同时不超过9次
2.设计与分析
1.分析
本次作业无需在原有的基础上增加新的类，只需要在选课系统中增加判断课程种类方法即可，可将输入的length作为判断的标准。
验证课程信息格式：检查每个课程信息是否符合指定的格式（课程名称+空格+课程性质+空格+考核方式）。
验证课程性质和考核方式匹配：确保输入的课程性质和考核方式相匹配，如果不匹配，则输出错误信息。
验证成绩信息格式：对于考试和考察的成绩信息，检查每个成绩信息是否符合指定的格式（学号+空格+姓名+空格+课程名称+空格+平时成绩+空格+期末成绩）；对于实验的成绩信息，检查每个成绩信息是否符合指定的格式（学号+空格+姓名+空格+课程名称+空格+实验次数+空格+第一次实验成绩+...+空格+最后一次实验成绩）。
验证成绩取值范围：对于平时成绩、期末成绩和实验成绩，验证它们的取值是否在0到100的范围内。
检查学号、姓名和课程名称长度：确保学号不超过8位数字、姓名不超过10个字符、课程名称不超过10个字符。
检查实验次数的范围：确保实验次数在4到9之间。
验证重复信息：检查是否存在相同的学号和课程信息，如果存在重复，则只保留第一个出现的信息。
2.设计
-
创建类和数据结构：创建表示学生、课程和成绩的类和数据结构，以便存储和处理输入的信息。
-
解析输入信息：根据给定的输入格式，解析并提取课程和成绩相关的信息。
-
校验输入：进行必要的校验，确保输入的合法性，包括成绩范围、长度限制等。
-
计算总成绩：根据不同类型的课程和考核方式，计算学生的总成绩。
-
统计平均分：基于所有学生和课程的成绩，计算学生所有课程总成绩的平均分、单门课程的成绩平均分和班级的所有课程总成绩平均分。
-
排序和输出结果：按照指定的输出格式，对计算结果进行排序并输出。
3.采坑心得
import java.util.*;
class Course {
String courseName;
String courseType;
String examinationType;
public Course(String courseName, String courseType, String examinationType) {
this.courseName = courseName;
this.courseType = courseType;
this.examinationType = examinationType;
}
}
class Grade {
String studentId;
String studentName;
String courseName;
List<Integer> scores;
public Grade(String studentId, String studentName, String courseName, List<Integer> scores) {
this.studentId = studentId;
this.studentName = studentName;
this.courseName = courseName;
this.scores = scores;
}
public int getFinalGrade() {
return scores.stream().mapToInt(Integer::intValue).sum() / scores.size();
}
public String getClassId() {
return studentId.substring(0, 6);
}
}
public class Main {
static Map<String, Course> courses = new HashMap<>();
static Map<String, List<Grade>> studentsGrades = new HashMap<>();
static Map<String, List<Grade>> coursesGrades = new HashMap<>();
static Map<String, List<Grade>> classGrades = new HashMap<>();
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextLine()) {
String input = scanner.nextLine();
if ("end".equals(input)) {
break;
}
String[] parts = input.split(" ");
if (parts.length <= 3) {
addCourse(input);
} else {
addGrade(input);
}
}
printStudentGrades();
printCourseGrades();
printClassGrades();
}
public static void addCourse(String input) {
String[] parts = input.split(" ");
if (parts.length < 2 || parts.length > 3) {
System.out.println("wrong format");
return;
}
String courseName = parts[0];
String courseType = parts[1];
String examinationType = parts.length == 3 ? parts[2] : "考试";
if (!"实验".equals(examinationType) && "必修".equals(courseType)) {
System.out.println(courseName + " : course type & access mode mismatch");
return;
}
if (courses.containsKey(courseName)) {
System.out.println(courseName + " : course already exists, ignoring new entry");
} else {
courses.put(courseName, new Course(courseName, courseType, examinationType));
}
}
public static void addGrade(String input) {
String[] parts = input.split(" ");
if (parts.length < 5 && parts.length != 3) {
System.out.println("wrong format");
return;
}
String studentId = parts[0];
String studentName = parts[1];
String courseName = parts[2];
int examTimes = parts.length > 3 ? Integer.parseInt(parts[3]) : 1;
if (!courses.containsKey(courseName)) {
System.out.println(studentId + " " + studentName + " : " + courseName + " does not exist");
return;
}
if ("实验".equals(courses.get(courseName).examinationType) && parts.length - 4 != examTimes) {
System.out.println(studentId + " " + studentName + " : access mode mismatch");
return;
}
List<Integer> scores = new ArrayList<>();
for (int i = 4; i < parts.length; i++) {
int score = Integer.parseInt(parts[i]);
if (score > 100 || score < 0) {
System.out.println("wrong format");
return;
}
scores.add(score);
}
if (parts.length == 3) {
scores.add(Integer.parseInt(parts[2]));
}
Grade grade = new Grade(studentId, studentName, courseName, scores);
studentsGrades.computeIfAbsent(studentId, k -> new ArrayList<>()).add(grade);
coursesGrades.computeIfAbsent(courseName, k -> new ArrayList<>()).add(grade);
classGrades.computeIfAbsent(grade.getClassId(), k -> new ArrayList<>()).add(grade);
}
public static void printStudentGrades() {
studentsGrades.values().stream()
.flatMap(List::stream)
.sorted(Comparator.comparing(g -> g.studentId))
.forEach(grade -> System.out.println(grade.studentId + " " + grade.studentName + " " + grade.getFinalGrade()));
}
public static void printCourseGrades() {
coursesGrades.forEach((key, grades) -> {
if (grades.isEmpty()) {
System.out.println(key + " has no grades yet");
return;
}
int totalGrade = grades.stream().mapToInt(Grade::getFinalGrade).sum();
System.out.println(key + " " + totalGrade / grades.size());
});
}
public static void printClassGrades() {
classGrades.forEach((key, grades) -> {
if (grades.isEmpty()) {
System.out.println(key + " has no grades yet");
return;
}
int totalGrade = grades.stream().mapToInt(Grade::getFinalGrade).sum();
System.out.println(key + " " + totalGrade / grades.size());
});
}
}
增加的类与类之间的关系没有整理清楚，同时对于类与类之间的关联性也没有准确的认知，对于组合和聚合之间的不同没有理解。
组合之间的关联性是强于聚合的，同时组合中的部分是无法分割出去使用，而聚合的部分是可以使用的，同时组合的生命周期是强于聚合的。
currenHaseMap注意 key和value的null值
没有进行程序的测试，同时没有考虑程序运行时可能出现的错误，以及出现错误后导致的其他功能的瘫痪
4.主要困难以及改进意见
1.困难
设计类时没有及时考虑到几个类之间包含的关系导致无法进行程序的基础设计
类与类之间的关联性没有具体设置和规划导致在程序设计后面出现思路的中断以及后面出现功能缺失而导致的增加类的数量。、
2.改进意见
没有进行程序的测试，同时没有考虑程序运行时可能出现的错误，以及出现错误后导致的其他功能的瘫痪
需要考虑到程序的稳定性以及类与类之间的关联，设计功能时所需要的涵盖的类
第八次作业总结
1.前言
本次考试主要考察类的设计，以及后续所出现的接口等方法。
类的结构设计，考察对于类设计的思路以及后续功能的实现
2.设计与分析
1.设计
成绩类中的分项成绩是由分项成绩类组合而成的，实现了组合关系的设计。相比于继承关系，在处理多个子类共有的行为时，组合关系更加灵活，能够适应变更。
例如，如果需要添加新的分项成绩类型或者修改计算总成绩的方式，使用组合关系可以更方便地进行调整和扩展。
2.分析
1. 对于每个学生，计算总成绩平均分： - 创建一个空的学生成绩列表 students_grades - 对于每个学生对象 student in 学生列表: - 创建一个空的成绩列表 grades - 对于每个成绩对象 grade in 成绩列表: - 计算成绩对象的总成绩 score = grade.计算总成绩() - 将 score 加入到 grades 列表中 - 计算总成绩平均分 avg_score = 平均(grades) - 将学生对象 student 和 avg_score 组成元组 (student, avg_score) 加入到 students_grades 列表中 - 根据学号对 students_grades 列表进行排序
2. 对于每门课程，计算总成绩平均分：
- 创建一个空的课程成绩列表 courses_grades
- 对于每个课程成绩对象 course_grade in 课程成绩列表: - 计算课程总成绩平均分 avg_score = course_grade.获取课程总成绩平均分() - 将课程成绩对象 course_grade 和 avg_score 组成元组 (course_grade, avg_score) 加入到 courses_grades 列表中 - 根据课程名称对 courses_grades 列表进行排序
3.采坑心得
import java.text.Collator;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
String s_record = s.nextLine();
ParseInput handle = new ParseInput();
while (!s_record.equals("end")) {
handle.parseInput(s_record);
s_record = s.nextLine();
}
handle.MySort();
handle.studentScore();
handle.CourseScore();
handle.ClassScore();
}
}
class ParseInput {
private final ArrayList<SelectCourse> selectCourses = new ArrayList<>();
private final ArrayList<Course> courses = new ArrayList<>();
private final ArrayList<Student> students = new ArrayList<>();
private final ArrayList<String> Class = new ArrayList<>();
private final HashMap<String, String> courseMethod = new HashMap<>();
public void parseInput(String input) {
String[] inputs = input.split(" ");
if (InputMatching.matchingInput(input) == 1) {
if (inputs.length > 7 && (Integer.parseInt(inputs[3]) < 4 || Integer.parseInt(inputs[3]) > 9)) {
System.out.println("wrong format");
return;
}
courseMethod.put(inputs[0], inputs[2]);
if (checkCourse(inputs[0]) != null) return;
else {
if (inputs[1].equals("必修") && (!inputs[2].equals("考试"))) {
System.out.println(inputs[0] + " : course type & access mode mismatch");
return;
} else if (inputs[1].equals("选修") && !(inputs[2].equals("考试") || inputs[2].equals("考察"))) {
System.out.println(inputs[0] + " : course type & access mode mismatch");
return;
} else if (inputs[1].equals("实验") && !(inputs[2].equals("实验"))) {
System.out.println(inputs[0] + " : course type & access mode mismatch");
return;
} else if (inputs[1].equals("实验") && inputs[2].equals("实验")) {
if (Integer.parseInt(inputs[3]) != inputs.length - 4) {
System.out.println(inputs[0] + " : number of scores does not match");
return;
} else {
double sum = 0;
for (int i = 4; i < inputs.length; i++) {
sum += Double.parseDouble(inputs[i]);
}
if (sum != 1.0) {
System.out.println(inputs[0] + " : weight value error");
return;
} else {
StringBuilder qz = new StringBuilder(inputs[4]);
for (int i = 5; i < inputs.length; i++) {
qz.append(" ").append(inputs[i]);
}
// System.out.println(qz);
if (qz.toString().equals(""))
courses.add(new Course(inputs[0], inputs[1], inputs[2]));
else
courses.add(new Course(inputs[0], inputs[1], inputs[2], qz.toString()));
}
}
} else {
StringBuilder qz = new StringBuilder(inputs[4]);
for (int i = 5; i < inputs.length; i++) {
qz.append(" ").append(inputs[i]);
}
if (qz.toString().equals(""))
courses.add(new Course(inputs[0], inputs[1], inputs[2]));
else
courses.add(new Course(inputs[0], inputs[1], inputs[2], qz.toString()));
}
}
} else if (InputMatching.matchingInput(input) == 2) {
Course findcourse = checkCourse(inputs[2]);
Student newStudent = new Student(inputs[0], inputs[1]);
if (!checkStudent(newStudent.getNum())) students.add(newStudent);
if (!checkClass(inputs[0].substring(0, 6))) {
Class.add(inputs[0].substring(0, 6));
}
if (checkSelect(inputs[0], inputs[2])) return;
if (findcourse == null) {
System.out.println(inputs[2] + " does not exist");
return;
} else if (findcourse.getMethod().equals("考试") && inputs.length != 5) {
System.out.println(inputs[0] + ' ' + inputs[1] + " : access mode mismatch");
} else if (findcourse.getMethod().equals("考察") && inputs.length != 4) {
System.out.println(inputs[0] + ' ' + inputs[1] + " : access mode mismatch");
} else if (findcourse.getMethod().equals("实验") && (inputs.length - 3 != findcourse.quanzhong.length)) {
System.out.println(inputs[0] + ' ' + inputs[1] + " : access mode mismatch");
} else {
SelectCourse newSelectCourse = new SelectCourse();
newSelectCourse.setCourse(findcourse);
Grade grade;
if (findcourse.getMethod().equals("考试")) {
ExamGrade examGrade = new ExamGrade();
examGrade.weightU = findcourse.quanzhong[0];
examGrade.weightF = findcourse.quanzhong[1];
examGrade.setUsualGrade(Integer.parseInt(inputs[3]));
examGrade.setFinalGrade(Integer.parseInt(inputs[4]));
grade = examGrade;
} else if (findcourse.getMethod().equals("实验")) {
NoExamGrade noExamGrade = new NoExamGrade();
double sumScore = 0;
int courseCount = 0;
for (int i = 3; i < inputs.length; i++) {
sumScore += (findcourse.quanzhong[i - 3] * Integer.parseInt(inputs[i]));
courseCount++;
}
if (courseCount < 4 || courseCount > 9) {
System.out.println("wrong format");
return;
}
noExamGrade.setFinalGrade((int) sumScore);
grade = noExamGrade;
} else {
NoExamGrade noExamGrade = new NoExamGrade();
noExamGrade.setFinalGrade(Integer.parseInt(inputs[3]));
grade = noExamGrade;
}
newSelectCourse.setGrade(grade);
newSelectCourse.setStudent(newStudent);
selectCourses.add(newSelectCourse);
}
} else System.out.println("wrong format");
}
private Course checkCourse(String courseName) {
for (Course course : courses) {
if (course.getName().equals(courseName)) return course;
}
return null;
}
private Boolean checkStudent(String num) {
for (Student student : students) {
if (student.getNum().equals(num)) return true;
}
return false;
}
private Boolean checkClass(String classnum) {
for (String cname : Class) {
if (cname.equals(classnum)) return true;
}
return false;
}
private Boolean checkSelect(String stunum, String cname) {
for (SelectCourse selectCourse : selectCourses) {
if (selectCourse.getStudent().getNum().equals(stunum) && selectCourse.getCourse().getName().equals(cname))
return true;
}
return false;
}
public void studentScore() {
for (Student student : students) {
double sum = 0;
int count = 0;
for (SelectCourse selectCourse : selectCourses) {
if (selectCourse.getStudent().getNum().equals(student.getNum())) {
sum += selectCourse.getGrade().getTotalGrade();
count++;
}
}
if (count == 0)
System.out.println(student.getNum() + ' ' + student.getName() + ' ' + "did not take any exams");
else System.out.println(student.getNum() + ' ' + student.getName() + ' ' + (int) (sum / count));
}
}
public void CourseScore() {
for (Course course : courses) {
double sumUsualScore = 0;
double sumFinalScore = 0;
double sumTotalScore = 0;
int count = 0;
for (SelectCourse selectCourse : selectCourses) {
if (selectCourse.getCourse().getName().equals(course.getName())) {
count++;
sumTotalScore += selectCourse.getGrade().getTotalGrade();
sumFinalScore += selectCourse.getGrade().getFinalGrade();
if (selectCourse.getCourse().getMethod().equals("考试")) {
sumUsualScore += selectCourse.getGrade().getUsualGrade();
}
}
}
if (count == 0) System.out.println(course.getName() + ' ' + "has no grades yet");
else if (course.getMethod().equals("考试"))
System.out.println(course.getName() + ' ' + (int) (sumUsualScore / count) + ' ' + (int) (sumFinalScore / count) + ' ' + (int) (sumTotalScore / count));
else if (course.getMethod().equals("考察"))
System.out.println(course.getName() + ' ' + (int) (sumFinalScore / count) + ' ' + (int) (sumTotalScore / count));
else if (course.getMethod().equals("实验"))
System.out.println(course.getName() + ' ' + (int) (sumFinalScore / count));
}
}
public void ClassScore() {
for (String classnum : Class) {
double sum = 0;
int count = 0;
for (SelectCourse selectCourse : selectCourses) {
if (selectCourse.getStudent().getNum().substring(0, 6).equals(classnum)) {
sum += selectCourse.getGrade().getTotalGrade();
count++;
}
}
if (count == 0) System.out.println(classnum + ' ' + "has no grades yet");
else System.out.println(classnum + ' ' + (int) (sum / count));
}
}
public void MySort() {
students.sort(Comparator.comparing(Student::getNum));
courses.sort((x, y) -> {
Collator instance = Collator.getInstance(Locale.CHINA);
return instance.compare(x.getName(), y.getName());
});
Collections.sort(Class);
}
}
abstract class Grade {
double TotalGrade;
public int getTotalGrade() {
return (int) TotalGrade;
}
public int getUsualGrade() {
return 0;
}
public int getFinalGrade() {
return 0;
}
}
class ExamGrade extends Grade {
int UsualGrade;
int FinalGrade;
double weightU;
double weightF;
public int getTotalGrade() {
return (int) (weightU * this.getUsualGrade() + weightF * this.getFinalGrade());
}
public int getUsualGrade() {
return UsualGrade;
}
public void setUsualGrade(int usualGrade) {
UsualGrade = usualGrade;
}
public int getFinalGrade() {
return FinalGrade;
}
public void setFinalGrade(int finalGrade) {
FinalGrade = finalGrade;
}
}
class NoExamGrade extends Grade {
int FinalGrade;
public int getTotalGrade() {
return FinalGrade;
}
public int getFinalGrade() {
return FinalGrade;
}
public void setFinalGrade(int finalGrade) {
FinalGrade = finalGrade;
}
}
class Course {
String name;
String kind;
String method;
Double[] quanzhong;
public Course(String name, String kind, String method) {
this.name = name;
this.kind = kind;
this.method = method;
}
public Course(String name, String kind, String method, String qz) {
this.name = name;
this.kind = kind;
this.method = method;
String[] QZ = qz.split(" ");
// System.out.println(QZ.length);
quanzhong = new Double[QZ.length];
for (int i = 0; i < quanzhong.length; i++) {
quanzhong[i] = Double.parseDouble(QZ[i]);
}
}
public String getName() {
return name;
}
public String getMethod() {
return method;
}
}
class Student {
String num;
String name;
public Student(String num, String name) {
this.num = num;
this.name = name;
}
public String getNum() {
return num;
}
public String getName() {
return name;
}
}
class SelectCourse {
Course course;
Student student;
Grade grade;
public Course getCourse() {
return course;
}
public void setCourse(Course course) {
this.course = course;
}
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public Grade getGrade() {
return grade;
}
public void setGrade(Grade grade) {
this.grade = grade;
}
}
class InputMatching {
static String stuNumMatching = "[0-9]{8}";
static String stuNameMatching = "\\S{1,10}";
static String scoreMatching = "(\\d|[1-9]\\d|100)";
static String courseNameMatching = "\\S{1,10}";
static String courseTypeMatching = "(选修|必修|实验)";
static String checkcourseTypeMatching = "(考试|考察|实验)";
static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching + " \\d" + "(\\s" + "0.\\d" + ")*";
static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
scoreMatching + "(\\s" + scoreMatching + ")*";
public static int matchingInput(String s) {
if (matchingCourse(s)) {
return 1;
}
if (matchingScore(s)) {
return 2;
}
return 0;
}
private static boolean matchingCourse(String s) {
return s.matches(courseInput);
}
private static boolean matchingScore(String s) {
return s.matches(scoreInput);
}
}
4.困难与改进意见
1.困难
仔细看清题目给的类图，事实上这些类图是非常重要的，但是我一开始没有重视类图，都是自己乱打一气，其实很不符合题目要求，但是结果是对的，前两次圆和矩形面积都没按类图写，导致后续的代码出现了问题
2.改进意见
arraylist 实现类RandomAccess接口（随机存取接口），这也就标志着arraylist是一个可以随机存取的列表 。适合采用下标方式来访问linkedlist，双向链表，两个元素本来就是有关联的，用foreach会高效
避免用序列化类在构造函数中为不变量赋值
要在本类中覆盖静态导入的变量和方法
本地的方法和属性会被使用。因为编译器有最短路径原则，以确保本类中的属性、方法优先
总结
对于这三次作业中所出现的面向对象的设计思路需要进行理解和吸收
同时还要学习其他库的使用和用法
思考架构也让我受益匪浅，至少能利用面向对象的思想，把一个具体的事物抽象出数据类型和操作了。真正的数据类型不仅仅是存储，而在于性质和操作的捆绑
这几次的作业也提高了我对于程序运行超时和内存不足问题的注意，同时还要减少函数的耦合性
浙公网安备 33010602011771号