7-3 课程成绩统计程序-2
分数 60
作者 蔡轲
单位 南昌航空大学
课程成绩统计程序-2在第一次的基础上增加了实验课，以下加粗字体显示为本次新增的内容。
某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
实验的总成绩等于课程每次实验成绩的平均分
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。
课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
课程性质输入项：必修、选修、实验
考核方式输入选项：考试、考察、实验
考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
考试/考查课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩
实验次数至少4次，不超过9次
实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
以上信息的相关约束：
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）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图（与第一次相同，其余内容自行补充）：
输入样例1:
在这里给出一组输入。例如：
java 实验 实验
20201103 张三 java 4 70 80 90
end
输出样例1:
在这里给出相应的输出。例如：
20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet
输入样例2:
在这里给出一组输入。例如：
java 实验 实验
20201103 张三 java 3 70 80 90
end
输出样例2:
在这里给出相应的输出。例如：
wrong format
java has no grades yet
输入样例3:
在这里给出一组输入。例如：
java 必修 实验
20201103 张三 java 3 70 80 90 100
end
输出样例3:
在这里给出相应的输出。例如：
java : course type & access mode mismatch
wrong format
输入样例4:
在这里给出一组输入。例如：
java 必修 实验
20201103 张三 java 4 70 80 90 105
end
输出样例4:
在这里给出相应的输出。例如：
java : course type & access mode mismatch
wrong format
输入样例5:
在这里给出一组输入。例如：
java 选修 考察
C语言 选修 考察
java实验 实验 实验
编译原理 必修 考试
20201101 王五 C语言 76
20201216 李四 C语言 78
20201307 张少军 编译原理 82 84
20201103 张三 java实验 4 70 80 90 100
20201118 郑觉先 java 80
20201328 刘和宇 java 77
20201220 朱重九 java实验 4 60 60 80 80
20201132 王萍 C语言 40
20201302 李梦涵 C语言 68
20201325 崔瑾 编译原理 80 84
20201213 黄红 java 82
20201209 赵仙芝 java 76
end
输出样例5:
在这里给出相应的输出。例如：
20201101 王五 76 20201103 张三 85 20201118 郑觉先 80 20201132 王萍 40 20201209 赵仙芝 76 20201213 黄红 82 20201216 李四 78 20201220 朱重九 70 20201302 李梦涵 68 20201307 张少军 83 20201325 崔瑾 82 20201328 刘和宇 77 C语言 65 65 java 78 78 java实验 77 编译原理 81 84 82 202011 70 202012 76 202013 77
import java.text.Collator;
import java.util.*;
public class Main {
// 存储成绩信息的List，每个元素为Grade对象
private static Map<String, Course> courses = new TreeMap<>();
// 存储成绩信息的List，每个元素为Grade对象
private static List<Grade> grades = new ArrayList<>();
public static void main(String[] args) {
int flag = 0;
Scanner scanner = new Scanner(System.in);
StringBuilder sb = new StringBuilder();
String line;
while (true) {
line = scanner.nextLine();
if (line.equals("end")) {
break;
}
sb.append(line).append("\n");
}
String[] st = sb.toString().split("\n");
// 解析输入的数据
for (String a:st) {
String[] data = a.split(" ");
for (String s : data) {
if (s.isEmpty() || s.contains(" ")) {
System.out.println("wrong format");
flag = 1;
}
}
if(flag ==0){
if (data.length >= 2 && data.length <= 3) {
// 课程信息
if (data[0].length() > 10) {
System.out.println("wrong format");
} else if (data[0].length() > 0 && data[0].length() <= 10){
if ((data[1].equals("必修") || data[1].equals("选修") || data[2].equals("实验"))) {
if (data.length == 3) {
if (data[2].equals("考试") || data[2].equals("考察") || data[2].equals("实验")) {
String courseName = data[0];
String courseType = data[1];
String accessMode = data[2];
addCourse(courseName, courseType, accessMode);
} else {
System.out.println("wrong format");
}
} else if (data.length == 2) {
String courseName = data[0];
String courseType = data[1];
addCourse(courseName, courseType, "考试");
} else {
System.out.println("wrong format");
}
} else {
System.out.println("wrong format");
}
} else {
System.out.println("wrong format");
}
} else if (data.length >=4 && data.length <= 5) {
// 成绩信息
if (data[0].length() != 8) {
System.out.println("wrong format");
} else if (courses.keySet().contains(data[2])){
String studentID = data[0];
String studentName = data[1];
String courseName = data[2];
String regex = "^\\d{1,2}$|^100$"; // 匹配0-100的数
if (data.length == 4) {
if(data[3].matches(regex)){
int finalGrade = Integer.parseInt(data[3]);
addGrade(studentID, studentName, courseName, -1, finalGrade);
} else {
System.out.println("wrong format");
}
} else if (data.length == 5){
if(data[3].matches(regex)){
int dailyGrade = Integer.parseInt(data[3]);
int finalGrade = Integer.parseInt(data[4]);
addGrade(studentID, studentName, courseName, dailyGrade, finalGrade);
} else {
System.out.println("wrong format");
}
}else {
System.out.println("wrong format");
}
}else {
System.out.println("wrong format");
}
} else if (data.length > 5 && data.length <= 13){
// 实验成绩信息
if (data[0].length() != 8) {
System.out.println("wrong format");
} else if (courses.keySet().contains(data[2])){
String studentID = data[0];
String studentName = data[1];
String courseName = data[2];
String regex = "^\\d{1,2}$|^100$"; // 匹配0-100的数
if ( data[3].matches("[4-9]")) {
for (int i = 4; i < data.length; i++) {
if(data[i].matches(regex)) {
}else{
break;
}
}
int i;
if(data[3].matches("[4-9]")){
i = Integer.parseInt(data[3]);
if(i != (data.length - 4)){
addGrade(studentID, studentName, courseName, 0,100);
}else{
switch (Integer.parseInt(data[3])) {
case 4:
int[] exGrades1 = {Integer.parseInt(data[4]),
Integer.parseInt(data[5]),
Integer.parseInt(data[6]),
Integer.parseInt(data[7])};
addGrade(studentID, studentName, courseName, exGrades1);
break;
case 5:
int[] exGrades2 = {Integer.parseInt(data[4]),
Integer.parseInt(data[5]),
Integer.parseInt(data[6]),
Integer.parseInt(data[7]),
Integer.parseInt(data[8])};
addGrade(studentID, studentName, courseName, exGrades2);
break;
case 6:
int[] exGrades3 = {Integer.parseInt(data[4]),
Integer.parseInt(data[5]),
Integer.parseInt(data[6]),
Integer.parseInt(data[7]),
Integer.parseInt(data[8]),
Integer.parseInt(data[9])};
addGrade(studentID, studentName, courseName, exGrades3);
break;
case 7:
int[] exGrades4 = {Integer.parseInt(data[4]),
Integer.parseInt(data[5]),
Integer.parseInt(data[6]),
Integer.parseInt(data[7]),
Integer.parseInt(data[8]),
Integer.parseInt(data[9]),
Integer.parseInt(data[10])};
addGrade(studentID, studentName, courseName, exGrades4);
break;
case 8:
int[] exGrades5 = {Integer.parseInt(data[4]),
Integer.parseInt(data[5]),
Integer.parseInt(data[6]),
Integer.parseInt(data[7]),
Integer.parseInt(data[8]),
Integer.parseInt(data[9]),
Integer.parseInt(data[10]),
Integer.parseInt(data[11])};
addGrade(studentID, studentName, courseName, exGrades5);
break;
case 9:
int[] exGrades6 = {Integer.parseInt(data[4]),
Integer.parseInt(data[5]),
Integer.parseInt(data[6]),
Integer.parseInt(data[7]),
Integer.parseInt(data[8]),
Integer.parseInt(data[9]),
Integer.parseInt(data[10]),
Integer.parseInt(data[11]),
Integer.parseInt(data[12])};
addGrade(studentID, studentName, courseName, exGrades6);
break;
default:
System.out.println("wrong format");
}
}
}
} else {
System.out.println("wrong format");
}
}else {
System.out.println("wrong format");
}
}else {
System.out.println("wrong format");
}
}
}
// 输出结果
outputStudentGradeAverage();
outputCourseGradeAverage();
outputClassGradeAverage();
}
/**
* 添加课程信息
*/
/**
* 添加课程信息
*/
private static void addCourse(String courseName, String courseType, String accessMode) {
if (courses.containsKey(courseName)) {
}else {
boolean isExam = "考试".equals(accessMode);
boolean isRequired = "必修".equals(courseType);
if (isRequired && !isExam) {
System.out.println(courseName + " : course type & access mode mismatch");
}else{
Course course = new Course(courseName, isRequired, isExam);
courses.put(courseName, course);
}
}
}
/**
* 添加成绩信息
*/
private static void addGrade(String studentID, String studentName, String courseName, int dailyGrade, int finalGrade) {
int flag1 = 0;
for(int i = 0; i < courses.get(courseName).getGrades().size(); i++) {
if (courses.get(courseName).getGrades().get(i).getStudentID().equals(studentID)){
flag1 = 1;
break;
}
}
if(flag1 == 0) {
if ((!courses.get(courseName).isExam() && courses.get(courseName).isRequired())) {
// 课程不存在，输出错误信息
System.out.println(courseName + " does not exist");
}
Course course = courses.get(courseName);
if ((dailyGrade == -1) == course.isExam()) {
// 成绩数量和考核方式不匹配，输出错误信息
System.out.println(studentID + " " + studentName + " : access mode mismatch");
finalGrade = -1;
}
if (!course.isExam() && course.isRequired()) {
finalGrade = -1;
}
if (finalGrade > 100 || dailyGrade > 100 ) {
System.out.println("wrong format");
} else {
Grade grade = new Grade(studentID, studentName, courseName, dailyGrade, finalGrade,null);
grades.add(grade);
courses.get(courseName).addGrade(grade);
}
}
}
private static void addGrade(String studentID, String studentName, String courseName, int[] exGrades) {
int flag1 = 0;
for(int i = 0; i < courses.get(courseName).getGrades().size(); i++) {
if (courses.get(courseName).getGrades().get(i).getStudentID().equals(studentID)){
flag1 = 1;
break;
}
}
if(flag1 == 0) {
if ((!courses.get(courseName).isExam() && courses.get(courseName).isRequired())) {
// 课程不存在，输出错误信息
System.out.println(courseName + " does not exist");
}
Course course = courses.get(courseName);
for (int i:exGrades) {
if (i < 0 || i > 100) {
System.out.println("wrong format");
return;
}
}
Grade grade = new Grade(studentID, studentName, courseName, -1, -2,exGrades);
grades.add(grade);
courses.get(courseName).addGrade(grade);
}
}
/**
* 输出学生所有课程总成绩的平均分
*/
private static void outputStudentGradeAverage() {
// 将grades按学号从小到大排序
Collections.sort(grades, Comparator.comparing(Grade::getStudentID));
// 使用TreeMap保存学生信息并排序
Map<String, Student> students = new TreeMap<>();
for (Grade grade : grades) {
String studentID = grade.getStudentID();
if (!students.containsKey(studentID)) {
students.put(studentID, new Student(studentID, grade.getStudentName()));
}
Student student = students.get(studentID);
student.addGrade(grade);
}
// 遍历并输出每个学生的平均分
for (String studentID : students.keySet()) {
Student student = students.get(studentID);
double averageGrade = student.getAverageGrade();
if (averageGrade == -1) {
System.out.println(studentID + " " + student.getStudentName() + " did not take any exams");
}
else {
System.out.println(studentID + " " + student.getStudentName() + " " + (int) averageGrade);
}
}
}
/**
* 输出单门课程成绩平均分
*/
private static void outputCourseGradeAverage() {
// 按课程名称的字母顺序排序
List<String> courseNames = new ArrayList<>(courses.keySet());
// 使用 Collator 比较字符串的大小，实现按照汉字字母顺序排序
Collator collator = Collator.getInstance(Locale.CHINA);
Collections.sort(courseNames, collator::compare);
for (String courseName : courseNames) {
Course course = courses.get(courseName);
if(!grades.isEmpty()){
for(int i=0;i<grades.size();i++)
course.addGrade(grades.get(i));
}
if(!course.isExam() && course.isRequired()) {
}else{
if (course.isExam()) {
// 考试课程，需要计算平时成绩和总成绩平均分
double dailyAverage = course.getDailyAverage();
double finalAverage = course.getFinalAverage();
double totalAverage = course.getTotalAverage();
if(totalAverage == -1||totalAverage == 0)
{
System.out.println(courseName + " has no grades yet");
} else {
System.out.println(courseName + " " + (int) dailyAverage + " " + (int) finalAverage + " " + (int) totalAverage);
}
} else {
// 考察课程，只需要计算期末成绩平均分
double finalAverage = course.getFinalAverage();
double totalAverage = course.getTotalAverage();
if (finalAverage == -1) {
System.out.println(courseName + " has no grades yet");
} else if (finalAverage == -2) {
System.out.println(courseName + " " + (int) totalAverage);
}else {
System.out.println(courseName + " " + (int) finalAverage + " " + (int) finalAverage);
}
}
}
}
}
/**
* 输出班级所有课程总成绩平均分
*/
private static void outputClassGradeAverage() {
Map<String, List<Grade>> classGrades = new HashMap<>();
for (Grade grade : grades) {
String studentID = grade.getStudentID();
String classID = studentID.substring(0, 6);
if (!classGrades.containsKey(classID)) {
classGrades.put(classID, new ArrayList<>());
}
classGrades.get(classID).add(grade);
}
List<String> classIDs = new ArrayList<>(classGrades.keySet());
// 按班级号从小到大排序
Collections.sort(classIDs);
for (String classID : classIDs) {
List<Grade> classGradeList = classGrades.get(classID);
double totalGradeSum = 0;
int totalGradeCount = 0;
for (Grade grade : classGradeList) {
double totalGrade = grade.getTotalGrade();
if (!Double.isNaN(totalGrade)) {
totalGradeSum += totalGrade;
totalGradeCount++;
}
}
if (totalGradeSum == -1) {
System.out.println(classID + " has no grades yet");
} else {
double totalAverageGrade = totalGradeSum / totalGradeCount;
System.out.println(classID + " " + (int) totalAverageGrade);
}
}
}
}
class Course {
String courseName; // 课程名称
boolean isRequired; // 是否必修
boolean isExam; // 是否考试
List<Grade> grades = new ArrayList<>(); // 成绩列表
public Course(String courseName, boolean isRequired, boolean isExam) {
this.courseName = courseName;
this.isRequired = isRequired;
this.isExam = isExam;
}
public boolean isExam() {
return isExam;
}
public boolean isRequired() {
return isRequired;
}
/**
* 添加成绩到该课程
*/
public void addGrade(Grade grade) {
if (grade.getCourseName().equals(courseName)) {
grades.add(grade);
}
}
/**
* 计算平时成绩平均分
*/
public double getDailyAverage() {
int dailyGradeSum = 0;
int dailyGradeCount = 0;
for (Grade grade : grades) {
int dailyGrade = grade.getDailyGrade();
if (dailyGrade != -1) {
dailyGradeSum += dailyGrade;
dailyGradeCount++;
}
}
if (dailyGradeCount == 0) {
return 0;
}
return (double) dailyGradeSum / dailyGradeCount;
}
/**
* 计算期末成绩平均分
*/
public double getFinalAverage() {
int finalGradeSum = 0;
int finalGradeCount = 0;
for (Grade grade : grades) {
int finalGrade = grade.getFinalGrade();
finalGradeSum += finalGrade;
finalGradeCount++;
}
if (finalGradeCount == 0) {
return -1;
}
return (double) finalGradeSum / finalGradeCount;
}
/**
* 计算总成绩平均分
*/
public double getTotalAverage() {
int totalGradeSum = 0;
int totalGradeCount = 0;
for (Grade grade : grades) {
double totalGrade = grade.getTotalGrade();
if (!Double.isNaN(totalGrade)) {
totalGradeSum += totalGrade;
totalGradeCount++;
}
}
if (totalGradeCount == 0) {
return 0;
}
return (double) totalGradeSum / totalGradeCount;
}
public List<Grade> getGrades(){
return grades;
}
}
class Grade {
private String studentID; // 学号
private String studentName; // 姓名
private String courseName; // 课程名称
private int dailyGrade; // 平时成绩，如果没有则为-1
private int finalGrade; // 期末成绩
private int[] exGrades; // 实验成绩
public Grade(String studentID, String studentName, String courseName, int dailyGrade, int finalGrade, int[] exGrades) {
this.studentID = studentID;
this.studentName = studentName;
this.courseName = courseName;
this.dailyGrade = dailyGrade;
this.finalGrade = finalGrade;
this.exGrades = exGrades;
}
public String getStudentID() {
return studentID;
}
public String getStudentName() {
return studentName;
}
public String getCourseName() {
return courseName;
}
public int getDailyGrade() {
return dailyGrade;
}
public int getFinalGrade() {
return finalGrade;
}
/**
* 计算总成绩
*/
public double getTotalGrade() {
if(dailyGrade == -1 && finalGrade == -2){
int sum = 0;
int count = 0;
for (int i:exGrades) {
sum+=i;
count++;
}
return (int)sum / count;
} else if (dailyGrade == -1) {
return finalGrade;
} else if (finalGrade == -1){
return finalGrade;
} else {
return dailyGrade * 0.3 + finalGrade * 0.7;
}
}
}
class Student {
private List<Grade> grades = new ArrayList<>(); // 成绩列表
private String studentID; // 学号
private String studentName; // 姓名
public Student(String studentID, String studentName) {
this.studentID = studentID;
this.studentName = studentName;
}
public String getStudentName() {
return studentName;
}
public void addGrade(Grade grade) {
if (grade.getStudentID().equals(studentID)) {
grades.add(grade);
}
}
/**
* 计算该学生所有课程的总成绩平均分
*/
public double getAverageGrade() {
int totalGradeSum = 0;
int totalGradeCount = 0;
for (Grade grade : grades) {
double totalGrade = grade.getTotalGrade();
if (!Double.isNaN(totalGrade)) {
totalGradeSum += totalGrade;
totalGradeCount++;
}
}
if (totalGradeCount == 0) {
return -1;
} else {
return (double) totalGradeSum / totalGradeCount;
}
}
}
题目要求设计一个课程成绩统计程序，主要包括输入和输出两个部分。根据题目的描述，我们可以设计以下解决方案：
-
输入部分：
- 首先，需要输入课程信息，包括课程名称、课程性质（必修或选修）和考核方式（考试或考察）。
- 然后，需要输入学生成绩信息，包括学号、姓名、课程名称和具体成绩。
- 输入以"end"作为结束标志。
-
输出部分：
- 针对每门课程，输出该课程的平均分和及格率。
- 针对每位学生，输出该学生的总成绩和平均分。
- 输出格式要求按照题目给定的格式进行。
在提交源码的过程中，我遇到了一些问题和收获了一些心得。以下是我总结的详实情况：
问题：
- 编译错误：在提交源码之前，我首先要确保代码能够正确地编译。如果出现编译错误，我会检查错误信息并尝试找到解决方法。这可能涉及到检查语法错误、缺少依赖项或者库等。
- 运行时错误：即使代码能够成功编译，也可能在运行时出现错误。这可能是由于逻辑错误、空指针引用或者数据类型不匹配等原因导致的。为了解决这些问题，我会使用调试工具来跟踪代码执行过程，定位错误并进行修复。
心得：
- 代码的可读性：在提交源码之前，我意识到代码的可读性对于其他人来阅读和理解非常重要。因此，我会注重代码的命名规范、注释以及代码结构的清晰性，以便其他人可以轻松地理解我的代码。
- 测试的重要性：在提交源码之前，我会进行全面的测试，以确保代码在各种情况下都能正常运行。我会编写不同的测试用例，包括正常情况、边界情况和异常情况，以验证代码的正确性和稳定性。
- 版本控制：我会使用版本控制工具（如Git）来管理我的代码。这样可以轻松地跟踪代码的变更，回滚错误的更改，并与团队成员进行协作。
以上是我在提交源码过程中遇到的问题和得到的经验教训。通过解决问题和积累经验，我能够不断提高代码质量和效率。
7-1 立体图形问题
分数 10
作者 段喜龙
单位 南昌航空大学
编程求得正方体和正三棱锥的表面积和体积，要求必须体现扩展性（继承）和多态性。
类结构如下图所示（参考）：
试编程完成如上类设计，主方法源码如下（可直接拷贝使用）：
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
double side = input.nextDouble();
display(new Cube(side));
display(new RegularPyramid(side));
}
其中，display(Solid solid)方法为定义在Main类中的静态方法，作用为体现程序的多态性。
注：正三棱锥的体积计算公式为底面积*高/3。
输入格式:
输入一个实型数，分别作为正方体的边长和正三棱锥的边长。
输出格式:
分别输出正方体的表面积、体积以及正棱锥的表面积和体积。保留两位小数，建议使用String.format(“%.2f”,value)
进行小数位数控制。
输入样例:
在这里给出一组输入。例如：
2.5
输出样例:
在这里给出相应的输出。例如：
37.50 15.63 10.83 1.84
import java.util.Scanner; abstract class Solid { protected double side; public Solid(double side) { this.side = side; } public abstract double s(); public abstract double v(); public void display() { System.out.printf("%.2f\n", s()); System.out.printf("%.2f\n", v()); } } class Cube extends Solid { public Cube(double side) { super(side); } public double s() { return 6 * side * side; } public double v() { return side * side * side; } } class RegularPyramid extends Solid { public RegularPyramid(double side) { super(side); } public double s() { return 4 * Math.sqrt(3) * side * side/4; } public double v() { return Math.sqrt(2) / 12 * side * side * side; } } public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); double side = input.nextDouble(); Solid cube = new Cube(side); Solid pyramid = new RegularPyramid(side); cube.display(); pyramid.display(); } }
该程序包含以下几个类：
- Solid（抽象类）：表示一个立体对象，包含一个受保护的属性side（边长），以及抽象方法s()和v()分别用于计算表面积和体积。还有一个display()方法用于打印结果。
- Cube（继承自Solid）：表示一个立方体对象，通过调用父类的构造函数来初始化side属性，并实现了s()和v()方法来计算立方体的表面积和体积。
- RegularPyramid（继承自Solid）：表示一个正四面体对象，通过调用父类的构造函数来初始化side属性，并实现了s()和v()方法来计算正四面体的表面积和体积。
- Main类：包含了主函数main()，用于从用户输入获取边长，并创建并显示立方体和正四面体的表面积和体积。
在主函数中，首先创建了一个Scanner对象input，用于从标准输入中读取用户输入。然后通过input.nextDouble()获取用户输入的边长。接下来，创建了一个Cube对象和一个RegularPyramid对象，分别传入用户输入的边长作为参数。最后，调用cube.display()和pyramid.display()来显示立方体和正四面体的表面积和体积。
7-2 课程成绩统计程序-3
分数 64
作者 蔡轲
单位 南昌航空大学
课程成绩统计程序-3在第二次的基础上修改了计算总成绩的方式，
要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。
完成课程成绩统计程序-2、3两次程序后，比较继承和组合关系的区别。思考一下哪一种关系运用上更灵活，更能够适应变更。
题目最后的参考类图未做修改，大家根据要求自行调整，以下内容加粗字体显示的内容为本次新增的内容。
某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
实验的总成绩等于课程每次实验成绩乘以权重后累加而得。
课程权重值在录入课程信息时输入。（注意：所有分项成绩的权重之和应当等于1）
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重。
考试课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重
考察课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重
实验次数至少4次，不超过9次
课程性质输入项：必修、选修、实验
考核方式输入选项：考试、考察、实验
考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
考试/考查课程成绩信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），实验次数要和实验课程信息中输入的分项成绩数量保持一致｝
实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
以上信息的相关约束：
1）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
2）学号由8位数字组成
3）姓名不超过10个字符
4）课程名称不超过10个字符
5）不特别输入班级信息，班级号是学号的前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）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
6）如果解析实验课程信息时，输入的分项成绩数量值和分项成绩权重的个数不匹配，输出：课程名称+" : number of scores does not match"
7）如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图（与第一次相同，其余内容自行补充）：
输入样例1:
在这里给出一组输入。例如：
java 实验 实验 4 0.2 0.3 0.2 0.3
end
输出样例1:
在这里给出相应的输出。例如：
java has no grades yet
输入样例2:
在这里给出一组输入。例如：
java 实验 实验 4 0.2 0.3 0.2
end
输出样例2:
在这里给出相应的输出。例如：
java : number of scores does not match
输入样例3:
在这里给出一组输入。例如：
java 实验 实验 4 0.2 0.3 0.2 0.1
end
输出样例3:
在这里给出相应的输出。例如：
java : weight value error
输入样例4:
在这里给出一组输入。例如：
java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100
end
输出样例4:
在这里给出相应的输出。例如：
20201116 张三 86
java 86
202011 86
输入样例5:
在这里给出一组输入。例如：
java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100 80
end
输出样例5:
在这里给出相应的输出。例如：
20201116 张三 : access mode mismatch
20201116 张三 did not take any exams
java has no grades yet
202011 has no grades yetimport java.text.Collator; import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); School school = new School(); String a; a=in.nextLine(); while(!a.equals("end")) { school.parseInput(a); a=in.nextLine(); } school.showStudent(); school.showCourse(); school.showClass(); } } class InputMatching { static String stuNumMatching = "[0-9]{8}"; static String stuNameMatching = "\\S{1,10}"; static String scoreMatching = "([1-9]?[0-9]|100)"; static String scoreMatching1 = "([1-9]\\d?|0|100)( ([1-9]\\d?|0|100)){0,20}"; static String courseNameMatching = "\\S{1,10}"; static String courseTypeMatching = "(选修|必修|实验)"; static String checkCourseTypeMatching = "(考试|考察)"; static String experimentNumber = "[4-9]"; static String weightMatching="(\\d+(\\.\\d+)?)"; static String weightMatching1="(\\d+(\\.\\d))( (\\d+(\\.\\d))){0,20}"; static String courseInput1 = courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching;//考察课 static String courseInput2= courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching+" "+weightMatching+" "+weightMatching;//考式课 static String courseInput3= courseNameMatching + " " + courseTypeMatching + " " + "实验"+" "+experimentNumber+" "+weightMatching1;//实验课 static String courseInput4= courseNameMatching + " " + "必修" +" "+weightMatching+" "+weightMatching; static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " + scoreMatching; static String scoreInput1 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " + scoreMatching + " "+scoreMatching; static String scoreInput2 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +scoreMatching + " "+scoreMatching+ " "+scoreMatching; static String scoreInput3 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " "+scoreMatching1; 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(courseInput1)||s.matches(courseInput2)||s.matches(courseInput3)||s.matches(courseInput4)); } private static boolean matchingScore(String s) { return (s.matches(scoreInput)||s.matches(scoreInput1)||s.matches(scoreInput2)||s.matches(scoreInput3)); } } class School { Class currentClass ;//临时班级 Student currentStudent ;//临时学生 Course currentCourse;//临时课 ArrayList<Class> classes = new ArrayList<>(); ArrayList<Student> students = new ArrayList<>(); ResourceOfCourse resourceOfCourse =new ResourceOfCourse(); void parseInput(String line) { switch (InputMatching.matchingInput(line)) { case 0 : System.out.println("wrong format"); break; case 1 : addCourse(line);break; case 2 : addScore(line);break; } } void addCourse(String line) { String [] parts = line.split(" "); String weightMatching = "(\\d+(\\.\\d+)?)"; currentCourse = resourceOfCourse.searchCourse(parts[0]); if(currentCourse == null){ if (line.matches("\\S* 必修* 考试"+" "+weightMatching+" "+weightMatching)) { if(judgeSumOfWeight(Arrays.copyOfRange(parts,3, 5))) { currentCourse = new Course(parts[0], parts[2],Arrays.copyOfRange(parts,3, 5)); resourceOfCourse.addCourse(currentCourse); } else { System.out.println(parts[0]+" : weight value error"); } } else if (line.matches("\\S* 选修* 考试"+" "+weightMatching+" "+weightMatching)) { currentCourse = new Course(parts[0], parts[2],Arrays.copyOfRange(parts,3, 5)); resourceOfCourse.addCourse(currentCourse); } else if (line.matches("\\S* 选修* 考察")) { currentCourse = new Course(parts[0], parts[2],null); resourceOfCourse.addCourse(currentCourse); } else if(parts[1].equals("实验")&&parts[2].equals("实验")) { if(parts.length-4!=Integer.parseInt(parts[3])) { System.out.println(parts[0]+" : number of scores does not match"); } else { if(judgeSumOfWeight(Arrays.copyOfRange(parts, 4, parts.length))) { currentCourse = new Course(parts[0], parts[2], Arrays.copyOfRange(parts, 4, parts.length)); resourceOfCourse.addCourse(currentCourse); } else { System.out.println(parts[0]+" : weight value error"); } } } else if (line.matches("\\S* 必修"+" "+weightMatching+" "+weightMatching)) { currentCourse = new Course(parts[0], "考试",Arrays.copyOfRange(parts,2, 4)); resourceOfCourse.addCourse(currentCourse); } else { System.out.println(parts[0] + " : course type & access mode mismatch"); } } } boolean judgeSumOfWeight(String[] weights) { float sum = 0; for (String weight : weights) { sum += Float.parseFloat(weight); } return !(Math.abs(sum - 1) > 0.00001); } void addScore(String line) { String[] s=line.split(" "); String classNum = s[0].substring(0, 6); String studentNum = s[0]; String studentName = s[1]; if(searchClass(classNum)==null) { currentClass = new Class(classNum); addClass(currentClass); currentStudent = new Student(studentNum, studentName); currentClass.addStudent(currentStudent); students.add(currentStudent); solveScore(line); } else { currentClass = searchClass(classNum); if(currentClass.searchStudent(studentNum) == null) { currentStudent = new Student(studentNum,studentName); currentClass.addStudent(currentStudent); } else { currentStudent = currentClass.searchStudent(studentNum); } if(!students.contains(currentStudent)) { students.add(currentStudent); } solveScore(line); } } void solveScore(String line) { String [] parts = line.split(" "); //20201116 张三 java 70 80 90 100 String courseName=parts[2]; currentCourse = resourceOfCourse.searchCourse(parts[2]); if (currentCourse != null) { String[] scores=Arrays.copyOfRange(parts,3, parts.length); if(currentCourse.weights.size()==scores.length) { if(!currentStudent.courses.contains(currentCourse)) { int curScore; double curNormalScore = 0.0, curExamScore = 0.0; if (currentCourse.checkWay.equals("考试")) { curNormalScore += Integer.parseInt(scores[0]) * currentCourse.weights.get(0); curExamScore += Integer.parseInt(scores[1]) * currentCourse.weights.get(1); } else { for (int i = 0; i < scores.length; i++) curExamScore += Integer.parseInt(scores[i]) * currentCourse.weights.get(i); } curScore = (int)(curNormalScore + curExamScore); currentCourse.setScore( curScore); currentStudent.setScore(curScore); currentStudent.addCourse(); currentClass.setSore(curScore); currentClass.courseNum++; } } else { System.out.println(parts[0] + " " + parts[1] + " : access mode mismatch"); } } else { System.out.println(courseName + " does not exist"); } } Class searchClass(String classNum) { for (Class aClass : classes) { if (aClass.num.equals(classNum)) return aClass; } return null; } void addClass(Class currentClass) { classes.add(currentClass); } void showStudent() { Collections.sort(students); for(Student s : students) { s.stuShow(); } } void showClass() { Collections.sort(classes); for(Class s : classes) { s.classShow(); } } void showCourse() { Collections.sort(resourceOfCourse.resourceOfCourse); for(Course s : resourceOfCourse.resourceOfCourse) { s.courseShow(); } } } class Class implements Comparable<Class> { String num; double Score; int studentNum; int courseNum; Class(String num) { this.num = num; this.studentNum=0; this.Score =0; this.courseNum = 0; } ArrayList <Student> students = new ArrayList<>(); Student searchStudent(String studentNum) { for (Student student : this.students) { if (student.num.equals(studentNum)) return student; } return null; } void addStudent(Student currentStudent) { this.students.add(currentStudent); this.studentNum++; } void setSore(int curScore) { this.Score += curScore; } @Override public int compareTo(Class o) { return this.num.compareTo(o.num); } void classShow() { setGrade(); if(this.studentNum==0||courseNum==0) { System.out.println(this.num + " has no grades yet"); } else { System.out.println(this.num+" "+(int)this.Score); } } void setGrade() { if (this.studentNum != 0) { for (Student student : this.students) { if (student.courseCnt > 1) { this.studentNum += student.courseCnt - 1; } } this.Score = this.Score / this.studentNum; } } } class Student implements Comparable<Student> { String num; String name; int score; int courseCnt;//记录课程数量 ArrayList<Course> courses = new ArrayList<>(); Student(String num,String name) { this.num = num; this.name = name; this.score = 0; this.courseCnt = 0; } void addCourse() { this.courseCnt++; } void setScore(int curScore) { this.score += curScore;//考察成绩就是最后成绩 } @Override public int compareTo(Student o) { return this.num.compareTo(o.num); } void stuShow() { setGrade(); if(this.score ==-1) { System.out.println(this.num+" "+this.name+" did not take any exams"); } else { System.out.println(this.num+" "+this.name+" "+this.score); } } void setGrade() { if(this.courseCnt ==0) { this.score =-1; } else { this.score = this.score /this.courseCnt; } } } class Course implements Comparable<Course> { String name; String checkWay; int stuCnt; int score; double normalScore; double examScore; ArrayList<Float> weights=new ArrayList<>(); Course(String name ,String checkWay,String[] str) { this.name = name; this.checkWay = checkWay; this.score = 0; this.normalScore = 0; this.examScore = 0; this.stuCnt = 0; setWeights(str); } void setWeights(String[] weights) { if(weights != null) for (String weight : weights) this.weights.add(Float.parseFloat(weight)); else this.weights.add(1.0F); } void setScore(int curScore) { score+=curScore; this.stuCnt++; } @Override public int compareTo(Course o) { Collator collator= Collator.getInstance(Locale.CHINA); return collator.compare(this.name,o.name); } void courseShow() { setGrade(); if(this.stuCnt ==0) { System.out.println(this.name+" has no grades yet"); } else { if(this.checkWay.equals("实验")) { System.out.println(this.name+" "+this.score); } else if(this.checkWay.equals("考试")) { System.out.println(this.name+" "+this.score ); } else { System.out.println(this.name+" "+this.score); } } } void setGrade() { if(this.stuCnt !=0) { this.score = score/this.stuCnt; } } } class ResourceOfCourse { ArrayList<Course> resourceOfCourse = new ArrayList<>(); void addCourse(Course newCourse) { resourceOfCourse.add(newCourse); } Course searchCourse(String name) { for (Course c : resourceOfCourse) { if (c.name.equals(name)) return c; } return null; } }
根据题目要求，我们需要设计一个课程成绩统计程序。程序需要实现以下功能：
-
输入课程信息：包括课程名称、课程性质、考核方式、分项成绩数量和每个分项成绩的权重。
-
输入考试/考察课程成绩信息：包括学号、姓名、课程名称、平时成绩（可选）、期末成绩。
-
输入实验课程成绩信息：包括学号、姓名、课程名称以及每次实验的成绩。
-
根据输入的成绩信息计算总成绩：根据不同的考核方式，计算考试总成绩、考察总成绩和实验总成绩。
-
统计学生所有课程总成绩的平均分、单门课程总成绩平均分和班级所有课程总成绩平均分。
-
输出结果：按要求输出学生课程总成绩平均分、单门课程成绩和班级所有课程总成绩平均分。
为了实现上述功能，可以设计以下类：
-
成绩类（Score）：包含学号、姓名、课程名称和成绩等属性。
-
分项成绩类（SubScore）：包含成绩分值和权重两个属性。
-
课程类（Course）：包含课程名称、课程性质、考核方式和分项成绩等属性。课程类组合了分项成绩类。
-
学生类（Student）：包含学号、姓名和课程成绩列表等属性。学生类关联了课程类。
-
班级类（Class）：包含班级号和学生列表等属性。班级类关联了学生类。
-
成绩统计类（ScoreStatistics）：包含处理成绩信息和计算平均分的方法。
根据题目要求，我们还需要对继承关系进行修改，将成绩类的继承关系改为组合关系。即将成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类。
在编写代码时，我们需要注意处理异常情况，如课程名称不匹配、成绩数量和考核方式不匹配等问题。还需要注意保留小数位和取整的处理方式。
最后，根据输入和计算结果，按要求格式输出相应的统计信息。
总结：
通过这次的阶段性总结，我深刻懂得了以下一些事情，首先，在解决问题时，需要理解问题需求：在开始编写代码之前，我首先花时间仔细阅读和理解问题的需求。这有助于我确定代码的目标和要求，并为我后续的编码工作提供指导。其次需要设计合适的类和方法：针对问题需求，我学会了如何设计合适的类和方法。这包括确定类的属性和行为，以及定义方法的输入和输出。良好的类设计可以提高代码的可读性和可维护性。总的来说，这次Java作业让我更深入地了解了面向对象编程的思想和Java语言的特性。我也学到了一些重要的编程技巧和最佳实践，这将对我的未来编码工作有所帮助。