NCHU PTA7-8次PTA题目集（成绩计算系列）以及期末考试

一、前言：

最近几次的pta作业改变了以往的计价系统，转而要求我们计算成绩。起初，我并没有遇到太大困难，只需要多花一些时间就能完成。然而，由于前几次作业做得不好，导致我在接下来的两次作业中也没有取得好成绩。随着我们对Java的学习越来越深入，我们学习了类的概念，并进一步探讨了父类和接口的用法。这些知识在pta作业中能够派上用场，使我们的代码更加简洁和清晰。然而，对于这些知识的运用仍然存在一定的难度，需要我们有一定的理解才能灵活运用。

二、设计与分析：

PTA7：

我遇到的问题是我最麻烦困扰我最久的问题。程序在未运行时没有标红也就是没有语法错误，但是在运行时一直传出空指针错误

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.Collator;
import java.util.*;
import java.util.stream.Collectors;

public class Main {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
MessageGetAndPrint messageGetAndPrint = new MessageGetAndPrint();
messageGetAndPrint.print = new Print();
for(;;){
String message = in.readLine();
if(message.equals("end")) {
messageGetAndPrint.print.personPrint(messageGetAndPrint.students , messageGetAndPrint.courseSelections);
messageGetAndPrint.print.coursePrint(messageGetAndPrint.courses , messageGetAndPrint.courseSelections);
messageGetAndPrint.print.classPrint(messageGetAndPrint.classes , messageGetAndPrint.courseSelections);
break;
}
messageGetAndPrint.getMessage(message);
}
}
}
class Class {
private String classNum;
HashMap<String , Student> students;
Class(String classNum) {
setClassNum(classNum);
}
public void setClassNum(String classNum) {
this.classNum = classNum;
}
public String getClassNum() {
return classNum;
}
public void addStudent(Student student) {
students.put(student.getStudentNum() , student);
}
public void deleteStudent(String studentNum) {
students.remove(studentNum);
}
}
class Student {
private String name;
private String studentNum;
Student(String name , String studentNum) {
setName(name);
setStudentNum(studentNum);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getStudentNum() {
return studentNum;
}
public void setStudentNum(String studentNum) {
this.studentNum = studentNum;
}
}
class Course {
private String className;
private int classQuality;
private int assessmentMethodology;
Course(String className , int classQuality , int assessmentMethodology) {
setClassName(className);
setClassQuality(classQuality);
setAssessmentMethodology(assessmentMethodology);
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public int getClassQuality() {
return classQuality;
}
public void setClassQuality(int classQuality) {
this.classQuality = classQuality;
}
public int getAssessmentMethodology() {
return assessmentMethodology;
}
public void setAssessmentMethodology(int assessmentMethodology) {
this.assessmentMethodology = assessmentMethodology;
}
}
class CourseSelection {
Student student;
Course course;
Grade grade;
}
abstract class Grade {
int allGrade;
abstract void getAllGrade();
}
class GradeA extends Grade {
private int finalGrade;
private int usualGrade;
GradeA(int finalGrade , int usualGrade) {
setFinalGrade(finalGrade);
setUsualGrade(usualGrade);
}
public void setFinalGrade(int finalGrade) {
this.finalGrade = finalGrade;
}
public int getFinalGrade() {
return finalGrade;
}
public void setUsualGrade(int usualGrade) {
this.usualGrade = usualGrade;
}
public int getUsualGrade() {
return usualGrade;
}
@Override
void getAllGrade() {
allGrade = (int) (finalGrade*0.7+usualGrade*0.3);
}
}
class GradeB extends Grade {
private int finalGrade;
GradeB(int finalGrade) {
setFinalGrade(finalGrade);
}
public void setFinalGrade(int finalGrade) {
this.finalGrade = finalGrade;
}
public int getFinalGrade() {
return finalGrade;
}
@Override
void getAllGrade() {
allGrade = finalGrade;
}
}
class GradeC extends Grade {
ArrayList<Integer> usualGrades;
GradeC(ArrayList<Integer> usualGrades) {
this.usualGrades = usualGrades;
}
@Override
void getAllGrade() {
allGrade = 0;
for(int x:usualGrades){
allGrade+=x;
}
allGrade = allGrade/usualGrades.size();
}
}
class Print {
public void personPrint(HashMap<String , Student> students , ArrayList<CourseSelection> courseSelections) {
Set<String> set = students.keySet();
Object[] arr=set.toArray();
Arrays.sort(arr);
for(Object key:arr) {
int x = 0 , y = -1;
for (CourseSelection courseSelection : courseSelections) {
if (students.get(key).getStudentNum().equals(courseSelection.student.getStudentNum())) {
if(y == -1)
y = 0;
courseSelection.grade.getAllGrade();
x += courseSelection.grade.allGrade;
y++;
}
}
if(y == -1) {
System.out.println(students.get(key).getStudentNum()+" "+students.get(key).getName()+" did not take any exams");
continue;
}
x = x / y;
System.out.println(students.get(key).getStudentNum()+" "+students.get(key).getName()+" "+x);

}
}
public void coursePrint(HashMap<String , Course> courses , ArrayList<CourseSelection> courseSelections) {
List<String> list = courses.keySet().stream().collect(Collectors.toList());
Collections.sort(list , new SoftName());
for(String key:list) {
int x = 0 , y = -1 , f = 0 , u = 0 , uy = -1 , s = -1;
for (CourseSelection courseSelection : courseSelections) {
if (courses.get(key).getClassName().equals(courseSelection.course.getClassName())) {
if(y == -1)
y = 0;
if(courses.get(key).getAssessmentMethodology() == 1 && uy == -1)
uy = 0;
if(courses.get(key).getAssessmentMethodology() == 3 && s == -1)
s = 0;
courseSelection.grade.getAllGrade();
x += courseSelection.grade.allGrade;
if(courseSelection.grade instanceof GradeA) {
f += ((GradeA) courseSelection.grade).getFinalGrade();
u += ((GradeA) courseSelection.grade).getUsualGrade();
uy++;
}
if(courseSelection.grade instanceof GradeB) {
f += ((GradeB) courseSelection.grade).getFinalGrade();
}
y++;
}
}
if(y == -1) {
System.out.println(courses.get(key).getClassName()+" has no grades yet");
continue;
}
x = x/y;
f = f/y;
if(s == 0) {
System.out.println(courses.get(key).getClassName()+" "+x);
continue;
}
if(uy == -1) {
System.out.println(courses.get(key).getClassName()+" "+f+" "+x);
}
if(uy != -1) {
u = u/uy;
System.out.println(courses.get(key).getClassName()+" "+u+" "+f+" "+x);
}
}
}
public void classPrint(HashMap<String , Class> classes , ArrayList<CourseSelection> courseSelections) {
Set<String> set = classes.keySet();
Object[] arr=set.toArray();
Arrays.sort(arr);
for(Object key:arr) {
int x = 0 , y = -1;
for(CourseSelection courseSelection : courseSelections) {
if(classes.get(key).students.containsKey(courseSelection.student.getStudentNum())) {
if(y == -1) {
y = 0;
}
courseSelection.grade.getAllGrade();
x += courseSelection.grade.allGrade;
y++;
}
}
if(y == -1) {
System.out.println(classes.get(key).getClassNum()+" has no grades yet");
continue;
}
x = x/y;
System.out.println(classes.get(key).getClassNum()+" "+x);
}
}
public void wrongFormat() {
}
public void courseExist(String name) {
}
public void courseMatch(String studentNum , String studentName) {
System.out.println(studentNum+" "+studentName+" : access mode mismatch");
}
public void courseMatch(String name) {
System.out.println(name+" : course type & access mode mismatch");
}
static class SoftName implements Comparator<String>{
public int compare(String name1 , String name2) {
Comparator<Object> compare = Collator.getInstance(Locale.CHINA);
return compare.compare(name1 , name2);
}
}
}
class MessageGetAndPrint {
Print print;
HashMap<String , Class> classes = new HashMap<>();
HashMap<String , Student> students = new HashMap<>();
HashMap<String , Course> courses = new HashMap<>();
ArrayList<CourseSelection> courseSelections = new ArrayList<>();
public void getMessage(String getInput) {
String[] message = getInput.split(" ");
if(getInput.matches("^(\\S{1,10})( )(必修)$")) {
int i = 1, j = 1;
if(courses.containsKey(message[0])) {
return;
}
Course course = new Course(message[0], i, j);
courses.put(message[0], course);
return;
}
if(getInput.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)$")) {
int i = 0, j = 0;
if(message[1].equals("必修")) {
i = 1;
}
if(message[1].equals("选修")) {
i = 2;
}
if(message[1].equals("实验")) {
i = 3;
}
if(message[2].equals("考试")) {
j = 1;
}
if(message[2].equals("考察")) {
j = 2;
}
if(message[2].equals("实验")) {
j = 3;
}
if(i == 1 && j != 1) {
print.courseMatch(message[0]);
return;
}
if(i == 3 && j != 3) {
print.courseMatch(message[0]);
return;
}
if(i != 3 && j == 3) {
print.courseMatch(message[0]);
return;
}
if(courses.containsKey(message[0])) {
return;
}
Course course = new Course(message[0], i, j);
courses.put(message[0], course);
return;
}
if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)( )([0-9]|[1-9][0-9]|100)$")) {
for(CourseSelection courseSelection:courseSelections) {
if(courseSelection.student.getStudentNum().equals(message[0])&&courseSelection.student.getName().equals(message[1])&&courseSelection.course.getClassName().equals(message[2])) {
return;
}
}
Student student = new Student(message[1], message[0]);
students.put(message[0] , student);
String classNum = message[0].substring(0 , 6);
if(!classes.containsKey(classNum)) {
Class aClass = new Class(classNum);
classes.put(classNum , aClass);
classes.get(classNum).students = new HashMap<>();
}
classes.get(classNum).students.put(message[0], student);
if(!courses.containsKey(message[2])) {
print.courseExist(message[2]);
return;
}
if(courses.get(message[2]).getAssessmentMethodology() != 1) {
print.courseMatch(message[0] , message[1]);
return;
}
CourseSelection courseSelection = new CourseSelection();
courseSelection.student = student;
courseSelection.course = courses.get(message[2]);
int finalGrade = Integer.parseInt(message[4]);
int usualGrade = Integer.parseInt(message[3]);
courseSelection.grade = new GradeA(finalGrade , usualGrade);
courseSelections.add(courseSelection);
return;
}
if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|10{2})$")) {
for(CourseSelection courseSelection:courseSelections) {
if(courseSelection.student.getStudentNum().equals(message[0])&&courseSelection.student.getName().equals(message[1])&&courseSelection.course.getClassName().equals(message[2])) {
return;
}
}
Student student = new Student(message[1], message[0]);
students.put(message[0] , student);
String classNum = message[0].substring(0 , 6);
if(!classes.containsKey(classNum)) {
Class aClass = new Class(classNum);
classes.put(classNum , aClass);
classes.get(classNum).students = new HashMap<>();
}
classes.get(classNum).addStudent(student);
if(!courses.containsKey(message[2])) {
print.courseExist(message[2]);
return;
}
if(courses.get(message[2]).getAssessmentMethodology() != 2) {
print.courseMatch(message[0] , message[1]);
return;
}
CourseSelection courseSelection = new CourseSelection();
courseSelection.student = student;
courseSelection.course = courses.get(message[2]);
int finalGrade = Integer.parseInt(message[3]);
courseSelection.grade = new GradeB(finalGrade);
courseSelections.add(courseSelection);
return;
}
if(getInput.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([4-9])( )((([0-9]|[1-9][0-9]|100)( ))+)([0-9]|[1-9][0-9]|100)$")) {
for(CourseSelection courseSelection:courseSelections) {
if(courseSelection.student.getStudentNum().equals(message[0])&&courseSelection.student.getName().equals(message[1])&&courseSelection.course.getClassName().equals(message[2])) {
return;
}
}
Student student = new Student(message[1], message[0]);
students.put(message[0] , student);
String classNum = message[0].substring(0 , 6);
if(!classes.containsKey(classNum)) {
Class aClass = new Class(classNum);
classes.put(classNum , aClass);
classes.get(classNum).students = new HashMap<>();
}
classes.get(classNum).addStudent(student);
if(!courses.containsKey(message[2])) {
print.courseExist(message[2]);
return;
}
if(courses.get(message[2]).getAssessmentMethodology() != 3) {
print.courseMatch(message[0] , message[1]);
return;
}
int usualNum = Integer.parseInt(message[3]);
if(message.length-4 != usualNum) {
print.courseMatch(message[0] , message[1]);
return;
}
CourseSelection courseSelection = new CourseSelection();
courseSelection.student = student;
courseSelection.course = courses.get(message[2]);
ArrayList<Integer> usualGrades = new ArrayList<>();
for(int i = 1;i <= usualNum;i++) {
usualGrades.add(Integer.parseInt(message[3+i]));
}
courseSelection.grade = new GradeC(usualGrades);
courseSelections.add(courseSelection);
return;
}
print.wrongFormat();
}
}

首先，代码定义了几个类：Student（学生）、Course（课程）、Class（班级）、Grade（成绩）等。每个类都有相应的属性和方法来描述和操作学生、课程、班级和成绩信息。

在 Main 类中，程序通过读取控制台输入的信息，创建 MessageGetAndPrint 对象，并调用其中的方法来处理输入的信息。同时，还定义了 Print 类来输出不同类型的统计信息。

MessageGetAndPrint 类的 getMessage 方法根据不同的输入格式，从输入中提取信息并进行相应的处理，比如添加学生、课程，设置成绩等操作。同时，根据输入的内容，调用 Print 类的方法进行输出。

整体而言，这段代码实现了一个简单的学生成绩管理系统，可以处理学生、课程和成绩信息，并能够按照要求进行统计和输出。

结果分析：

从在Source Monitor上代码质量分析结果中可以看出整体代码复杂度不是很高，具有一定的可读性。从上图数据中也可以看出大部分数值都在正常范围内，没有很复杂的地方

PTA8：

此次作业又增加了一些需求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。这样就需要我们重新设计类以及代码的一些结构，很遗憾我没啥实力做不对

踩坑心得：

作为一个Java的初学者，我的学习过程中遇到了很多问题和困难。在这里，我想分享一些我在Java学习中的心得体会，希望对其他初学者有所帮助。

首先，我认为理解面向对象思想是Java编程的基础。在学习Java时，我遇到了很多有关对象、类、继承、封装等概念的问题。例如，在设计程序时，如何正确地定义类、如何合理使用继承和封装等问题。通过学习这些概念，我逐渐掌握了Java的面向对象编程思想，也能够更好地组织自己的代码结构。

其次，异常处理是Java编程中必须要掌握的知识点。在我的学习过程中，我发现如果程序没有进行异常处理，很容易出现程序崩溃的情况。因此，我学会了使用try-catch语句块来捕获异常，并及时处理或输出错误信息，以提高程序的健壮性。

另外，集合框架也是Java编程中一个非常重要的知识点。在我的学习过程中，我遇到了很多需要管理数据的情况。通过学习Java的集合框架，我能够更方便地操作和管理数据。但是，在使用集合框架时，我也遇到了一些问题，如空指针异常和并发修改异常等。通过学习和实践，我学会了如何避免这些问题，例如使用同步控制来避免并发修改异常。

同时，在实际开发中，我也经常需要处理字符串。Java提供了很多关于字符串的操作方法，例如拼接、截取、分割等。但是，在我的学习过程中，我发现如果频繁地对字符串进行修改，会导致内存浪费。因此，我学会了使用StringBuilder或StringBuffer类来处理大量的字符串操作，以提高程序的性能。

最后，我认为坚持学习和实践是学好Java编程的关键。在我的学习过程中，我遇到了很多问题和困难，但只要坚持学习、积极思考，并勇于尝试解决问题，就一定能够逐渐掌握Java编程的技巧和方法。

总之，在学习Java编程时，要注意理解面向对象思想、掌握异常处理、熟悉集合框架、了解字符串操作、注意内存管理等方面的知识。同时，坚持学习和实践也是非常重要的。

改进建议：

代码改进非常重要，重复的代码会增加程序的复杂性，降低可读性，从而使后续改进变得困难。此外，在主函数中过多的if判断语句和for循环会拖慢程序的运行速度。因此，在日后的编程中，我们应该花更多时间去优化代码，删除不必要的重复代码。同时，尽量减少在主函数中使用if语句，以降低整体复杂度。

通过不断打磨代码，我们可以提高程序的质量和可维护性。避免重复代码可以使用方法抽取等技术进行优化。另外，可以考虑使用数据结构和算法来优化循环和判断逻辑，提高程序的效率。

总之，优化代码是一个持续的过程，需要我们在编程中时刻关注并不断改进。只有通过精益求精的态度和良好的编码习惯，才能写出高质量、高效率且易于维护的代码。

总结：

在学习Java的过程中，我获得了许多宝贵的经验和技能。以下是我对这一学习经历的综合性总结：

1. 基础知识的扎实掌握：学习Java的第一步是掌握基础知识，例如变量、数据类型、运算符等。通过系统的课程学习和练习，我能够熟练地运用这些基础知识，并且理解Java语言的核心概念和特性。

2. 面向对象编程的应用：Java是一种面向对象的编程语言，因此深入理解面向对象编程的思想是非常重要的。我通过学习Java中的类、对象、继承、多态等概念，能够编写出结构清晰、易于维护的代码。

3. Java API和开发工具的使用：Java提供了大量的API，包括集合框架、输入输出、网络编程等。我通过学习和使用这些API，能够更加高效地编写代码。同时，我还学会了开发工具的使用，例如Eclipse和IntelliJ IDEA等，使编程工作更加方便和舒适。

4. Web开发技术的应用：Java在Web应用程序开发中广泛应用，例如Servlet、JSP、Spring框架和SpringMVC等。我通过学习这些技术，能够熟练地开发Web应用程序，并且了解RESTful API的设计和实现。

5. 数据库操作和ORM框架的应用：Java还提供了强大的数据库操作支持，例如JDBC和Hibernate等ORM框架。我学会了使用MySQL等关系型数据库，并能够利用JDBC技术进行数据的增删改查操作。同时，我还学习了Hibernate等ORM框架的使用，简化了数据库操作的流程。

总的来说，学习Java是一项非常有价值的经历。在这个过程中，我不仅获得了扎实的编程基础和丰富的开发技能，还培养了自主学习和探索精神。这些知识和技能将对我的职业发展起到重要的支持作用，并且我会继续保持学习的态度，不断提升自己的技术水平。