一、前言：
三次pta题目集知识点丰富，包括了一开始如何创建Java基本形式，接着相关的命名及其使用，以及后面的知识结合。并且三次题目集的题量还算中规中矩，一开始，较为基础，题目多一点，方便学生进行学习和理解；接着进阶一点，难度提升的同时，适当减少了习题量；到最后，基本上题目以第二题的课程成绩统计程序-1为主。
这三次的pta题目呈阶梯式上升的难度，由第一次十分钟甚至更少时间的一题，到第二次作业一两个小时才能做出一题，再到第三次作业花一整天时间才能解出一个题，并且许多都要借鉴一下别人的思路，但是虽然难度提升了，但是我们对于Java语言的了解也逐步提升。从中我学会了许多：
关于Java：
1）注意使用时的print（）println（）printf（）的细微差别；
2）Java中包的使用问题，与C语言中的各种头文件include< >相似；
3）Java中字符串内容的比较与C语言的比较差异，字符串使用str.equals(s)：str是对比的字符串，s是需要对比字符串的内容，也可以str.equals("s")：这个是对比str字符串中内容是否是“s”字母；
还有一种字符串内容对比是使用str.charAt(i)=='？'将字符串的指定位置进行数组化进行内容的对比，str是字符串，i是字符串各个内容的坐标位置，‘ ？’中？代表的是要对比内容；
4） public 表示共有：类的数据成员和函数可以被该类对象和派生类访问。
private 私有型：自己的类可以访问，但派生类不能访问。
protected 保护型：自身类和派生类可以访问相当于自身的private型成员，它同private的区别就是在对待派生类的区别上。（子类函数也可以访问）；
5）nextLine（）与next（）的区别；nextLine（）以Enter键结束，不会过滤空格，但next（）读取到空白字符结束；
6）Java中String对象创建后即不会改变，对应操作只是产生了新的对象
7）字符串中str.substring（n,m）,截取字符串str中的第n位开始截取到m位，创建一个新的字符串
关于java和C语言区别：
1）与C语言命名相似，都采用英文命名，驼峰法命名函数（C语言叫法），Java中称为方法，C语言中成员变量Java中成为属性；
2）C语言是与Java的面向对象不同，C语言是通用程序设计语言，Java是面向对象的编程语言，C语言按行运行，Java按模块运行；
3）C语言有指针，Java中没有，但其数组有其指针的功能；
4）Java中可变量的赋值是引用
二、设计与分析
题目集2，7-1：
题目：7-1 成绩计算-1-类、数组的基本运用
创建学生类，包含
属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）
方法：计算总分、计算平均分
输入5个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
浮点数保留小数的相关知识可参考：
https://blog.csdn.net/huaishuming/article/details/17752365
输入格式:
5个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+语文成绩+英文空格+数学成绩+英文空格+物理成绩
例如：
22201311 张琳 80 80 80
22201312 黄昊 66 82 81
22201313 李少辰 77 76 80
22201314 袁婷 62 79 90
22201315 朱哲一 74 98 94
输出格式:
5个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 240 80.00
22201312 黄昊 229 76.33
22201313 李少辰 233 77.67
22201314 袁婷 231 77.00
22201315 朱哲一 266 88.67
代码如下：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int i;
int arrayLength = 5;
Student[] stu = new Student[arrayLength];
for (i = 0; i < arrayLength; i++){
String ID = input.next();
String name = input.next();
int math = input.nextInt();
int chinese = input.nextInt();
int physics = input.nextInt();
stu[i] = new Student(ID, name, chinese, math, physics);
}
for (i = 0; i < arrayLength; i++){
System.out.printf("%s %s %d %.2f\n",stu[i].getID(),stu[i].getName(),stu[i].getTotal(),stu[i].getAverage());
}
}
public static class Student{
private String ID;
private String name;
private int chinese;
private int math;
private int physics;
public Student(String ID, String name, int chinese, int math, int physics){
this.ID = ID;
this.name = name;
this.chinese = chinese;
this.math = math;
this.physics = physics;
}
public String getID(){
return ID;
}
public String getName(){
return name;
}
public int getChinese(){
return chinese;
}
public int getMath(){
return math;
}
public int getPhysics(){
return physics;
}
public int getTotal(){
return chinese + math + physics;
}
public double getAverage(){
return getTotal() / 3.0;
}
}
}
自我分析：
首先，我在main方法中创建了一个Scanner对象input，用于接收用户的输入。然后定义了一个整型变量arrayLength为5，表示学生数组的长度。
接下来，创建了一个名为stu的学生数组，其长度为arrayLength。通过一个循环，遍历数组的每个位置，并依次输入学生的信息（学号、姓名、数学成绩、语文成绩和物理成绩），然后使用这些信息创建一个Student对象，并将其存储到数组的对应位置上。
Student类是内部静态类，它包含了学生的基本信息和相关的方法。它有一个构造方法，接收学号、姓名、语文成绩、数学成绩和物理成绩作为参数，然后根据这些参数初始化对象的属性。
接下来，Student类提供了一系列的getter方法用于获取学生的各项属性，如学号、姓名、语文成绩、数学成绩、物理成绩等。
在Student类中还定义了两个计算方法：getTotal和getAverage。getTotal方法用于计算学生三科成绩的总和，而getAverage方法则通过调用getTotal方法来获取总分，然后除以3.0得到平均分。
最后，在main方法中，使用一个循环遍历学生数组，并分别输出每个学生的学号、姓名、总分和平均分。
PowerDesigner的相应类图：
题目集2，7-2：
题目：7-2 成绩计算-2-关联类
创建成绩类，包含：
属性：平时成绩（int）、期末成绩（int）
方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）
创建学生类，包含：
属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）
方法：计算总分、计算平均分
输入3个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365
输入格式:
依次输入3个学生的每门课成绩，每个学生成绩信息格式：
学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致
例如：
22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76
输出格式:
3个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 242 80.67
22201312 黄昊 234 78.00
22201313 李少辰 236 78.67
代码如下：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int i, j;
int arrayLength = 3;
Student[] stu = new Student[arrayLength];
Score[][] scores = new Score[arrayLength][arrayLength];
for (i = 0; i < arrayLength; i++){
stu[i] = new Student();
}
for (i = 0; i < arrayLength; i++){
for (j = 0; j < arrayLength; j++){
scores[i][j] = new Score();
}
}
double m1 = 0, m2 = 0, m3 = 0;
int[] n1 = new int[arrayLength];
int[] n2 = new int[arrayLength];
int[] n3 = new int[arrayLength];
for (i = 0; i < arrayLength; i++){
for (j = 0; j < arrayLength; j++){
stu[i].ID = input.next();
stu[i].name = input.next();
String lesson = input.next();
scores[i][j].regularscore = input.nextInt();
scores[i][j].examscore = input.nextInt();
m1 += scores[i][j].finalscore();
m2 += scores[i][j].regularscore;
m3 += scores[i][j].examscore;
}
n1[i] = (int) m1;
n2[i] = (int) m2;
n3[i] = (int) m3;
m1 = 0;
m2= 0;
m3 = 0;
}
for (i = 0; i < arrayLength; i++){
System.out.printf("%s %s %d %.2f %.2f %.2f\n", stu[i].getID(), stu[i].getName(), n1[i], n2[i] / 3.0, n3[i] / 3.0, n1[i] / 3.0);
}
}
public static class Score{
private int regularscore;
private int examscore;
public int finalscore(){
return (int) (regularscore * 0.4 + examscore * 0.6);
}
public Score(int regularscore, int examscore){
this.examscore = examscore;
this.regularscore = regularscore;
}
public Score(){
this(0, 0);
}
}
public static class Student{
private String ID;
private String name;
private int chinese;
private int math;
private int physics;
public Student(String ID, String name, int chinese, int math, int physics){
this.ID = ID;
this.name = name;
this.chinese = chinese;
this.math = math;
this.physics = physics;
}
public Student(){
this("", "", 0, 0, 0);
}
public String getID(){
return ID;
}
public String getName(){
return name;
}
public int getChinese(){
return chinese;
}
public int getMath(){
return math;
}
public int getPhysics(){
return physics;
}
public int getTotal(){
return chinese + math + physics;
}
public double getAverage(){
return getTotal() / 3.0;
}
}
}
自我分析：
首先，通过import语句导入了java.util.Scanner类。在main方法中，创建一个Scanner对象input，用于接收用户的输入。然后定义了整型变量i和j，表示循环遍历数组时使用的索引值，以及整型变量arrayLength为3，表示学生数组和成绩数组的长度。
接下来，创建了一个名为stu的学生数组和一个名为scores的成绩数组。通过两层循环，遍历数组的每个位置，并依次输入学生的信息（学号、姓名）和成绩（课程名称、平时分和考试分数），然后使用这些信息创建一个Student对象和一个Score对象，并将它们存储到对应的数组位置上。
Student类是内部静态类，它包含了学生的基本信息和相关的方法。它有两个构造方法，一个接收学号、姓名、语文成绩、数学成绩和物理成绩作为参数，另一个默认将这些属性初始化为0或空字符串。Student类还提供了一系列的getter方法用于获取学生的各项属性，例如学号、姓名、语文成绩、数学成绩、物理成绩等。此外，Student类还有两个计算方法：getTotal用于计算学生三科成绩的总和，而getAverage方法则通过调用getTotal方法来获取总分，然后除以3.0得到平均分。
Score类是另一个内部静态类，它表示每一门课的成绩（包括平时成绩和考试成绩）和最终得分。它有两个构造方法，一个接收平时成绩和考试成绩作为参数，另一个将这两个变量都初始化为0。Score类提供了一个计算最终得分的方法finalscore，该方法通过调用平时成绩和考试成绩来计算最终得分，并返回一个整数值。
在main方法中，使用double类型的变量m1、m2和m3分别存储学生三科成绩的总和，并定义三个整型数组n1、n2和n3分别存储每个学生的总分、平时成绩和考试成绩。然后对每个学生进行循环，遍历其所有成绩并累加每个成绩的总分、平时成绩和考试成绩。计算完成后将结果转换为整数，并存储到对应的数组位置上。最后，使用一个循环遍历学生数组，并分别输出每个学生的学号、姓名、总分和平均分。
PowerDesigner的相应类图：
题目集3，7-2：
题目：7-2 课程成绩统计程序-1
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。
课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
课程性质输入项：必修、选修
考核方式输入选项：考试、考察
课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
以上信息的相关约束：
1）平时成绩和期末成绩的权重默认为0.3、0.7
2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
3）学号由8位数字组成
4）姓名不超过10个字符
5）课程名称不超过10个字符
6）不特别输入班级信息，班级号是学号的前6位。
2、输出：
输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。
为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。
1）学生课程总成绩平均分按学号由低到高排序输出
格式：学号+英文空格+姓名+英文空格+总成绩平均分
如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出
格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
3）班级所有课程总成绩平均分按班级由低到高排序输出
格式：班级号+英文空格+总成绩平均分
如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"
异常情况：
1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
以上两种情况如果同时出现，按第一种情况输出结果。
3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"
4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
代码如下：
import java.util.*;
import java.text.Collator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class Matching{
private static final String id = "[0-9]{8}";
private static final String name = "\\S{1,10}";
private static final String course = "\\S{1,10}";
private static final String score = "([1-9]?[0-9]|100)";
private static final String courseType = "(选修|必修)";
private static final String test = "(考试|考察)";
private static final String courseInput = course + " " + courseType + " " + test;
private static final String score1 = id + " " + name + " " + course + " " +score;
private static final String score2 = id + " " + name + " " + course + " " +score + " " + score;
public static boolean Course(String input){
return input.matches(courseInput);
}
public static boolean Score(String input){
return input.matches(score1) || input.matches(score2);
}
}
class Course implements Comparable<Course>{
private final String name;
private final String nature;
private final String test;
public static String nature1 = "必修";
public static String nature2 = "选修";
public static String test1 = "考试";
public static String test2 = "考察";
public static int courseNameIndex = 0;
public static int natureIndex = 1;
public static int testIndex = 2;
public Course(String name, String nature, String test){
this.name = name;
this.nature = nature;
this.test = test;
}
public String getName(){
return name;
}
public String getNature(){
return nature;
}
public String getTest(){
return test;
}
public int compareTo(Course o){
Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
return compare.compare(name, o.getName());
}
public boolean check(){
if (this.nature.equals(Course.nature2)){
return true;
}
return this.nature.equals(Course.nature1) && this.test.equals(Course.test1);
}
}
class ExamGrade implements Grade{
private final int Grade1;
private final int Grade2;
public ExamGrade(int Grade1, int Grade2){
this.Grade1 = Grade1;
this.Grade2 = Grade2;
}
public int getGrade1(){
return Grade1;
}
public int getGrade2(){
return Grade2;
}
public int calculateTotalGrade(){
return (int) (Grade1 * 0.3 + Grade2 * 0.7);
}
}
class InspectionGrade implements Grade{
private final int grade2;
public InspectionGrade(int grade2){
this.grade2 = grade2;
}
public int getGrade2(){
return grade2;
}
public int calculateTotalGrade(){
return grade2;
}
}
interface Grade{
int getGrade2();
int calculateTotalGrade();
}
class Student implements Comparable<Student>{
private final String name;
private final int id;
private final int classId;
public static final int idIndex = 0;
public static final int nameIndex = 1;
public static final int courseIndex = 2;
public static final int Grade1Index = 3;
public static final int Grade2Index = 4;
public int getId(){
return id;
}
public String getName(){
return name;
}
public int getClassId(){
return classId;
}
public Student(int classId, int id, String name){
this.classId = classId;
this.id = id;
this.name = name;
}
@Override
public int compareTo(Student student){
return Integer.compare(id, student.id);
}
}
class Class implements Comparable<Class>{
private final int classId;
public int getClassId(){
return classId;
}
public Class(int classId){
this.classId = classId;
}
@Override
public int compareTo(Class otherClass){
return Integer.compare(classId, otherClass.classId);
}
}
class ChooseCourse{
private final Student student;
private final Course course;
private final Grade grade;
public ChooseCourse(Course course, Student student, Grade grade){
this.student = student;
this.course = course;
this.grade = grade;
}
public Student getStudent(){
return student;
}
public Course getCourse(){
return course;
}
public Grade getGrade(){
return grade;
}
}
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
ParseInput handle = new ParseInput();
while (true) {
String record = input.nextLine();
if (record.equals("end")) {
break;
}
handle.parseInput(record);
}
handle.showStudents();
handle.showCourses();
handle.showClasses();
}
}
class ParseInput{
ArrayList<Student> Students = new ArrayList<>();
ArrayList<Course> Courses = new ArrayList<>();
ArrayList<Class> Classes = new ArrayList<>();
ArrayList<ChooseCourse> ChooseCourses = new ArrayList<>();
private static final int inspectionDataLength = 4;
private static final int examDataLength = 5;
public void parseInput(String input){
if (Matching.Course(input)){
courseMessage(input);
return;
}
if (Matching.Score(input)){
gradeMessage(input);
return;
}
System.out.println("wrong format");
}
public void courseMessage(String input){
String[] inputData = input.split(" ");
String courseName = inputData[Course.courseNameIndex];
String nature = inputData[Course.natureIndex];
String test = inputData[Course.testIndex];
Course course = new Course(courseName, nature, test);
if (checkCourse(course)){
if (isExitedCourse(courseName))
Courses.add(course);
}
}
public void gradeMessage(String input){
String[] data = input.split(" ");
String studentIdStr = data[Student.idIndex];
String name = data[Student.nameIndex];
String courseName = data[Student.courseIndex];
int studentId = Integer.parseInt(studentIdStr);
int classId = Integer.parseInt(studentIdStr.substring(0, 6));
if (!isExitedClass(classId)){
Class newClass = new Class(classId);
Classes.add(newClass);
}
Student student = new Student(classId, studentId, name);
if (!isExitedStudent(studentId))
Students.add(student);
if (isExitedCourse(courseName)){
System.out.println(courseName + " " + "does not exist");
}
else {
Course course = getCourseByName(courseName);
if (data.length == inspectionDataLength && course.getTest().equals(Course.test2)){
int Grade2 = Integer.parseInt(data[Student.Grade1Index]);
InspectionGrade assessGrade = new InspectionGrade(Grade2);
ChooseCourse chooseCourse = new ChooseCourse(course, student, assessGrade);
if (!isExitedChooseCourse(studentId, courseName))
ChooseCourses.add(chooseCourse);
return;
}
if (data.length == examDataLength && course.getTest().equals(Course.test1)){
int Grade1 = Integer.parseInt(data[Student.Grade1Index]);
int Grade2 = Integer.parseInt(data[Student.Grade2Index]);
ExamGrade examGrade = new ExamGrade(Grade1, Grade2);
ChooseCourse chooseCourse = new ChooseCourse(course, student, examGrade);
ChooseCourses.add(chooseCourse);
return;
}
System.out.println(studentIdStr + " " + name + " " + ": access mode mismatch");
}
}
public boolean isExitedStudent(int id){
for (Student student : Students){
if (student.getId() == id)
return true;
}
return false;
}
public boolean isExitedClass(int classId){
for (Class Class : Classes){
if (Class.getClassId() == classId)
return true;
}
return false;
}
public boolean isExitedCourse(String name){
for (Course course : Courses) {
if (course.getName().equals(name))
return false;
}
return true;
}
public boolean checkCourse(Course course){
if (!course.check()){
System.out.println(course.getName() + " : course type & access mode mismatch");
return false;
}
return true;
}
public Course getCourseByName(String courseName){
for (Course course : Courses) {
if (course.getName().equals(courseName))
return course;
}
return null;
}
public boolean isExitedChooseCourse(int studentId, String courseName){
for (ChooseCourse chooseCourse : ChooseCourses){
if (chooseCourse.getStudent().getId() == studentId && chooseCourse.getCourse().getNature().equals(courseName)){
return true;
}
}
return false;
}
public void showStudents(){
Collections.sort(Students);
for (Student student : Students){
ArrayList<ChooseCourse> stuCourseSelects = getStudentSelects(student.getId());
if (!stuCourseSelects.isEmpty()){
System.out.println(student.getId() + " " + student.getName() + " " + getAvgTotalScore(stuCourseSelects));
}
else{
System.out.println(student.getId() + " " + student.getName() + " " + "did not take any exams");
}
}
}
public void showClasses(){
Collections.sort(Classes);
for (Class calss : Classes){
ArrayList<ChooseCourse> stuCourseSelects = getClassSelects(calss.getClassId());
if (!stuCourseSelects.isEmpty()){
System.out.println(calss.getClassId() + " " + getAvgTotalScore(stuCourseSelects));
}
else{
System.out.println(calss.getClassId() + " " + "has no grades yet");
}
}
}
public void showCourses(){
Collections.sort(Courses);
for (Course course : Courses){
ArrayList<ChooseCourse> stuCourseSelects = getCourseSelects(course.getName());
if (!stuCourseSelects.isEmpty()){
if (course.getTest().equals(Course.test1)){
System.out.println(course.getName() + " " + getAvgUsualScore(stuCourseSelects) + " " + getAvgFinalScore(stuCourseSelects) + " " + getAvgTotalScore(stuCourseSelects));
}
if (course.getTest().equals(Course.test2)){
System.out.println(course.getName() + " " + getAvgFinalScore(stuCourseSelects) + " " + getAvgTotalScore(stuCourseSelects));
}
}
else {
System.out.println(course.getName() + " " + "has no grades yet");
}
}
}
public ArrayList<ChooseCourse> getStudentSelects(int studentId){
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse chooseCourse : ChooseCourses){
if (chooseCourse.getStudent().getId() == studentId){
choose.add(chooseCourse);
}
}
return choose;
}
public ArrayList<ChooseCourse> getClassSelects(int classId){
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse chooseCourse : ChooseCourses){
if (chooseCourse.getStudent().getClassId() == classId){
choose.add(chooseCourse);
}
}
return choose;
}
public ArrayList<ChooseCourse> getCourseSelects(String courseName){
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse chooseCourse : ChooseCourses){
if (chooseCourse.getCourse().getName().equals(courseName)){
choose.add(chooseCourse);
}
}
return choose;
}
public int getAvgUsualScore(ArrayList<ChooseCourse> chooseCourses){
int sum = 0;
for (ChooseCourse chooseCourse : chooseCourses){
Course course = chooseCourse.getCourse();
Grade grade = chooseCourse.getGrade();
if (course.getTest().equals(Course.test1)){
sum += ((ExamGrade) grade).getGrade1();
}
}
return sum / chooseCourses.size();
}
public int getAvgFinalScore(ArrayList<ChooseCourse> chooseCourses){
int sum = 0;
for (ChooseCourse course : chooseCourses){
sum += course.getGrade().getGrade2();
}
return sum / chooseCourses.size();
}
public int getAvgTotalScore(ArrayList<ChooseCourse> chooseCourses){
int sum = 0;
for (ChooseCourse chooseCourse : chooseCourses){
sum += chooseCourse.getGrade().calculateTotalGrade();
}
return sum / chooseCourses.size();
}
}
自我分析：
重要是通过两大方法：
1.gradeMessage(String input) 方法：
通过字符串的分割操作 input.split(" ")，将输入的数据按照空格进行拆分，存储到 data 数组中。
从 data 数组中提取学生的信息，包括学号、姓名和课程名称。
将学号和班级编号转换为整数类型，并判断班级是否存在，如果不存在则创建一个新的班级对象并添加到班级列表。
创建学生对象，并检查学生是否已存在，如果不存在则将学生对象添加到学生列表。
判断课程是否存在，如果不存在则输出课程不存在的提示信息。
如果课程存在，根据不同的考试类型和成绩数据长度，创建不同类型的成绩对象，并将选择课程对象添加到选择课程列表中。
如果不符合以上条件，则输出访问模式不匹配的提示信息。
2.辅助方法：
isExitedStudent(int id)：判断给定的学生ID在学生列表中是否已存在，存在则返回true，否则返回false。
isExitedClass(int classId)：判断给定的班级ID在班级列表中是否已存在，存在则返回true，否则返回false。
isExitedCourse(String name)：判断给定的课程名称在课程列表中是否已存在，存在则返回false，否则返回true。
checkCourse(Course course)：检查课程对象的类型和访问模式是否匹配，不匹配则输出不匹配的提示信息。
getCourseByName(String courseName)：根据课程名称从课程列表中获取对应的课程对象。
isExitedChooseCourse(int studentId, String courseName)：判断给定的学生ID和课程名称在选择课程列表中是否已存在选择课程对象，存在则返回true，否则返回false。
showStudents()、showClasses()、showCourses()：展示学生列表、班级列表和课程列表的成绩相关信息。
getStudentSelects(int studentId)、getClassSelects(int classId)、getCourseSelects(String courseName)：根据学生ID、班级ID或课程名称从选择课程列表中获取对应的选择课程对象列表。
getAvgUsualScore(ArrayList<ChooseCourse> chooseCourses)、getAvgFinalScore(ArrayList<ChooseCourse> chooseCourses)、getAvgTotalScore(ArrayList<ChooseCourse> chooseCourses)：根据选择课程对象列表计算平均平时成绩、平均期末成绩和平均总成绩。
PowerDesigner的相应类图：
三、踩坑心得
因为第一次学习Java，在编写的过程中有许多东西都不理解，通过查询资料，才逐步理解。而且“printf”和“println”其实是有区别的，printf：通过格式化字符串可以指定输出的格式，例如控制输出的宽度、小数位数、填充字符等。格式化字符串中使用格式化指示符 % 加上转换字符来表示要输出的数据类型，如 %d 表示整数，%f 表示浮点数，%s 表示字符串等。println：不支持格式化输出，只能直接输出传入的参数值。一开始没有了解，经常运用不当，从而报错。相关的错误，还有许多。
四、主要困难以及改进建议
题目一：成绩计算-1-类、数组的基本运用
主要困难：在输入阶段与输出阶段容易出现错误
建议：用循环来简化代码。使用for循环来迭代输入指定数量的学生信息。
在读取输入数据时，需要注意处理可能的输入格式错误或异常情况。可以使用Scanner类的hasNext和hasNextInt方法来检查输入是否为有效的整数，并在输入错误时进行适当的处理。
在代码中添加适当的缩进和空行，以增加代码的可读性。同时，可以使用更具意义的变量名和方法名，以增加代码的可维护性。
题目二：成绩计算-2-关联类
主要困难：
-
提交的代码有些混乱，部分变量没有使用或者没有初始化
-
变量的命名不够直观，不便于阅读和理解
建议：
1.变量的命名可以更加直观和易懂。例如，可以用studentArray代替stu，scoresArray代替scores，这样可以增强代码的可读性。
2.在读取输入数据时，需要注意处理可能的输入格式错误或异常情况。例如，可以使用Scanner类的hasNext和hasNextInt方法来检查输入是否为有效的整数，并在输入错误时进行适当的处理。
3.在创建Score对象时，建议添加对输入参数的合法性检查，并在参数非法时抛出相应的异常或给出提示信息。
4.在代码中添加适当的缩进和空行，以增加代码的可读性。同时，可以使用更具意义的变量名和方法名，以增加代码的可维护性。
题目三：课程成绩统计程序-1
主要困难：代码中还存在部分错误，使得未实现最终结果。
建议：对于综合型题目，逻辑较为复杂的题目，还需要多加练习。
五、总结
我在这三次题目集中学习到了许多东西：
1.掌握了基础语法，包括变量、数据类型、运算符、控制流程（条件语句、循环语句）、数组等。
2.学习了如何创建类和对象，封装属性和行为，以及如何使用类和对象进行交互。了解构造方法、成员变量、成员方法、访问修饰符等概念，并能够灵活运用。
3.熟悉了Java开发工具，如Eclipse、IntelliJ IDEA等，并能够配置和调试开发环境。 4.对于报错的处理能力。Java提供了异常处理机制来处理程序运行时可能出现的错误。不断完善自己的代码，逐步提高程序的可靠性和稳定性。 同时也有一些我认为要进一步学习的点： 1.许多的Java语法还有欠缺，还需要不断地学习，进一步增加真身的能力。 2.多使用面对对象的方式看待问题，使用这种方式进行对题目的分析，细化为一个个小点，以后做题之前，先列出类，画出类图，进行思考。 标签：return,String,blog1,private,int,21207328,吴义隆,成绩,public From： https://www.cnblogs.com/wuyilongblog1/p/17746567.html