第一次博客作业
题目集1~3的总结性Blog
1.前言
第一次作业比较简单，也是老师发给我们练练手，主要还是熟悉一下java的输入输出格式，编写代码有些许不熟练，题目很多都在以前学习c语言的时候有写过类似的，但是仍然有一题有一个边界测试点没有通过，第二，三次作业开始就正式开始学习java了，难度也随之增加。有了第一次作业的铺垫，代码编写较第一次也更为流畅了一些。第二次完成代码作业时，有些测试点没有想到通过的方法。所以有的题并没有拿到满分。第三次作业难度增加，同时还有第二次作业时的题，同样的没有想到解决办法，有一道题通过了小部分的测试点，而另一道分值高的题通过了大部分的测试点。
2.设计与分析
7-1 成绩计算-1-类、数组的基本运用
分数 10
作者 蔡轲
单位 南昌航空大学
创建学生类，包含
属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）
方法：计算总分、计算平均分
输入5个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
浮点数保留小数的相关知识可参考：
https://blog.csdn.net/huaishuming/article/details/17752365
注意：未用学生类对象封装数据的，本题计0分
输入格式:
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
输入样例:
在这里给出一组输入。例如：
22201311 张琳 80 80 80
22201312 黄昊 66 82 81
22201313 李少辰 77 76 80
22201314 袁婷 62 79 90
22201315 朱哲一 74 98 94
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 240 80.00
22201312 黄昊 229 76.33
22201313 李少辰 233 77.67
22201314 袁婷 231 77.00
22201315 朱哲一 266 88.67
这题的代码如下：
import java.util.Scanner;
class Student {
private String studentNumber;
private String name;
private int chineseScore;
private int mathScore;
private int physicsScore;
public Student(String studentNumber, String name, int chineseScore, int mathScore, int physicsScore) {
this.studentNumber = studentNumber;
this.name = name;
this.chineseScore = chineseScore;
this.mathScore = mathScore;
this.physicsScore = physicsScore;
}
public int calculateTotalScore() {
return chineseScore + mathScore + physicsScore;
}
public double calculateAverageScore() {
return calculateTotalScore() / 3.0;
}
public String toString() {
int totalScore = calculateTotalScore();
double averageScore = calculateAverageScore();
return studentNumber + " " + name + " " + totalScore + " " + String.format("%.2f", averageScore);
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Student[] students = new Student[5];
for (int i = 0; i < 5; i++) {
String[] input = scanner.nextLine().split(" ");
String studentNumber = input[0];
String name = input[1];
int chineseScore = Integer.parseInt(input[2]);
int mathScore = Integer.parseInt(input[3]);
int physicsScore = Integer.parseInt(input[4]);
students[i] = new Student(studentNumber, name, chineseScore, mathScore, physicsScore);
}
for (Student student : students) {
System.out.println(student.toString());
}
scanner.close();
}
}
测试结果：
心得体会：
在解决这类问题时，首先要分析题目要求，明确需要创建的类、属性和方法，以及输入输出格式。使用面向对象的思维，创建一个合适的类来封装学生信息和相关操作，提高代码的可维护性和可扩展性。了解基本的字符串处理、类型转换和格式化输出等技巧，以满足题目的输入输出要求。最后，通过循环等方式处理多个学生的信息，完成整个程序。
7-2 成绩计算-2-关联类
分数 10
作者 蔡轲
单位 南昌航空大学
创建成绩类，包含：
属性：平时成绩（int）、期末成绩（int）
方法：计算总成绩（计算规则：平时成绩0.4+期末成绩0.6，保留整数部分，小数部分直接丢弃）
创建学生类，包含：
属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）
方法：计算总分、计算平均分
输入3个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365
注意：未用学生类对象封装数据的，本题计0分
输入格式:
依次输入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
输入样例:
在这里给出一组输入。例如：
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
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 242 76.67 84.00 80.67
22201312 黄昊 234 75.00 80.67 78.00
22201313 李少辰 236 83.67 76.00 78.67
编写的代码如下：
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
class Score {
public int dailyScore;
public int finalScore;
public Score(int dailyScore, int finalScore) {
this.dailyScore = dailyScore;
this.finalScore = finalScore;
}
public int calculateTotalScore() {
return (int) (dailyScore * 0.4 + finalScore * 0.6);
}
}
class Student {
private String studentNumber;
private String name;
private Map<String, Score> scores = new HashMap<>();
public Student(String studentNumber, String name) {
this.studentNumber = studentNumber;
this.name = name;
}
public void addScore(String courseName, int dailyScore, int finalScore) {
scores.put(courseName, new Score(dailyScore, finalScore));
}
public int calculateTotalScore() {
int totalScore = 0;
for (Score score : scores.values()) {
totalScore += score.calculateTotalScore();
}
return totalScore;
}
public double calculateAverageScore() {
int totalScore = calculateTotalScore();
int numCourses = scores.size();
return (double) totalScore / numCourses;
}
public double calculateAverageScore1() {
int totalScore = 0;
for (Score score : scores.values()) {
totalScore += score.dailyScore;
}
return (double)totalScore/scores.size();
}
public double calculateAverageScore2() {
int totalScore = 0;
for (Score score : scores.values()) {
totalScore += score.finalScore;
}
return (double)totalScore/scores.size();
}
public String getStudentInfo() {
int totalScore = calculateTotalScore();
double averageScore = calculateAverageScore();
return studentNumber + " " + name + " " + totalScore + " " +
String.format("%.2f",calculateAverageScore1() )+ " "+String.format("%.2f", calculateAverageScore2())+
" "+String.format("%.2f", averageScore);
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Map<String, Student> students
= new HashMap<>();
while (scanner.hasNextLine()) {
String inputLine = scanner.nextLine();
String[] parts = inputLine.split(" ");
String studentNumber = parts[0];
String name = parts[1];
String courseName = parts[2];
int dailyScore = Integer.parseInt(parts[3]);
int finalScore = Integer.parseInt(parts[4]);
if (!students.containsKey(studentNumber)) {
students.put(studentNumber, new Student(studentNumber, name));
}
Student student = students.get(studentNumber);
student.addScore(courseName, dailyScore, finalScore);
}
int count = 0;
for (Student student : students.values()) {
count++;
if(count!=students.values().size())
System.out.println(student.getStudentInfo());
else
System.out.print(student.getStudentInfo());
}
scanner.close();
}
}
测试结果：
代码运行结果：在课程顺序不一致这一测试点并未通过。
原因：没有编写关于课程识别的代码。
心得体会：
这道题是对上一道题的扩展，需要完成对课程的识别才能够拿取满分，解决这类题要使用面向对象的思维，创建一个合适的类来封装学生信息和相关操作，提高代码的可维护性和可扩展性。了解基本的字符串处理、类型转换和格式化输出等技巧，以满足题目的输入输出要求。此类题涵盖了类的设计和关联，对于理解如何在Java中创建和管理类的对象以及如何处理多个对象之间的关系非常有帮助。
7-2 课程成绩统计程序-1
分数 65
作者 蔡轲
单位 南昌航空大学
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图：
输入样例1:
仅有课程。例如：
java 必修 考试
数据结构 选修 考试
形式与政治 选修 考察
end
输出样例1:
在这里给出相应的输出。例如：
java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet
输入样例2:
单门考试课程 单个学生。例如：
java 必修 考试
20201103 张三 java 20 40
end
输出样例2:
在这里给出相应的输出。例如：
20201103 张三 34
java 20 40 34
202011 34
输入样例3:
单门考察课程 单个学生。例如：
java 选修 考察
20201103 张三 java 40
end
输出样例3:
在这里给出相应的输出。例如：
20201103 张三 40
java 40 40
202011 40
输入样例4:
考试课程 单个学生 不匹配的考核方式。例如：
java 必修 考试
20201103 张三 java 20
end
输出样例4:
在这里给出相应的输出。例如：
20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet
输入样例5:
单门课程，单个学生，课程类型与考核类型不匹配。例如：
java 必修 考察
20201103 张三 java 40
end
输出样例5:
在这里给出相应的输出。例如：
java : course type & access mode mismatch
java does not exist
20201103 张三 did not take any exams
202011 has no grades yet
输入样例6:
单门课程，多个学生。例如：
java 选修 考察
20201103 李四 java 60
20201104 王五 java 60
20201101 张三 java 40
end
输出样例6:
在这里给出相应的输出。例如：
20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53
输入样例7:
单门课程，单个学生，课程类型与考核类型不匹配。例如：
形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201103 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201103 李四 java 60
20201103 李四 数据库 70 78
end
输出样例7:
在这里给出相应的输出。例如：
20201103 李四 73
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
输入样例8:
单门课程，单个学生，成绩越界。例如：
数据结构 选修 考察
20201103 李四 数据结构 101
end
输出样例8:
在这里给出相应的输出。例如：
wrong format
数据结构 has no grades yet
输入样例9:
多门课程，多个学生，多个成绩。例如：
形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201205 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201102 王五 java 60
20201211 张三 数据库 70 78
end
输出样例9:
在这里给出相应的输出。例如：
20201102 王五 60
20201103 李四 87
20201205 李四 70
20201211 张三 75
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
202012 72
编写的代码如下：
import java.text.Collator;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
ParseInput parser = new ParseInput();
while (true) {
String input = scanner.nextLine();
if (input.equals("end")) {
break;
}
parser.parseInput(input);
}
parser.showStudents();
parser.showCourses();
parser.showClasses();
}
}
class ParseInput {
private ArrayList<Student> listStudent = new ArrayList<>();
private ArrayList<Course> listCourse = new ArrayList<>();
private ArrayList<Class> listClass = new ArrayList<>();
private ArrayList<ChooseCourse> listChooseCourse = new ArrayList<>();
public void parseInput(String input) {
InputMatching matcher = new InputMatching();
int flag = matcher.matchingInput(input);
switch (flag) {
case 0:
System.out.println("wrong format");
break;
case 1:
courseMessage(input);
break;
case 2:
gradeMessage(input);
break;
}
}
private void courseMessage(String input) {
String[] parts = input.split(" ");
String courseName = parts[0];
String type = parts[1];
String testType = parts[2];
Course course = new Course(courseName, type, testType);
if (checkCourse(course) && searchCourse(courseName) == null) {
listCourse.add(course);
}
}
private void gradeMessage(String input) {
String[] parts = input.split(" ");
String stuId = parts[0];
String classID = stuId.substring(0, 6);
String name = parts[1];
String courseName = parts[2];
if (searchClass(classID) == null) {
Class cls = new Class(classID);
listClass.add(cls);
}
Student student = new Student(classID, stuId, name);
if (!searchStudent(stuId)) {
listStudent.add(student);
}
Course course = searchCourse(courseName);
if (course == null) {
System.out.println(courseName + " does not exist");
} else {
if (parts.length == 4 && course.getTestType().equals("考察")) {
int finalGrade = Integer.parseInt(parts[3]);
AssessGrade assessGrade = new AssessGrade(finalGrade);
ChooseCourse chooseCourse = new ChooseCourse(course, student, assessGrade);
if (!searchChooseCourse(name, courseName)) {
listChooseCourse.add(chooseCourse);
}
} else if (parts.length == 5 && course.getTestType().equals("考试")) {
int usualGrade = Integer.parseInt(parts[3]);
int finalGrade = Integer.parseInt(parts[4]);
ExamGrade examGrade = new ExamGrade(usualGrade, finalGrade);
ChooseCourse chooseCourse = new ChooseCourse(course, student, examGrade);
listChooseCourse.add(chooseCourse);
} else {
System.out.println(stuId + " " + name + ": access mode mismatch");
}
}
}
private boolean checkCourse(Course course) {
int flag1, flag2;
switch (course.getType()) {
case "必修":
flag1 = 0;
break;
case "选修":
flag1 = 1;
break;
default:
flag1 = -1;
break;
}
switch (course.getTestType()) {
case "考试":
flag2 = 0;
break;
case "考察":
flag2 = 1;
break;
default:
flag2 = -1;
break;
}
if (flag1 == 0 && flag2 == 0) {
return true;
}
if (flag1 == 1 && (flag2 == 0 || flag2 == 1)) {
return true;
}
System.out.println(course.getCourseName() + " : course type & access mode mismatch");
return false;
}
private Class searchClass(String classId) {
for (Class cls : listClass) {
if (cls.getClassId().equals(classId)) {
return cls;
}
}
return null;
}
private Course searchCourse(String name) {
for (Course course : listCourse) {
if (course.getCourseName().equals(name)) {
return course;
}
}
return null;
}
private boolean searchStudent(String id) {
for (Student stu : listStudent) {
if (stu.getId().equals(id)) {
return true;
}
}
return false;
}
private boolean searchChooseCourse(String stuName, String courseName) {
for (ChooseCourse cs : listChooseCourse) {
if (cs.student.getStuName().equals(stuName) && cs.course.getCourseName().equals(courseName)) {
return true;
}
}
return false;
}
public void showStudents() {
Collections.sort(listStudent);
for (Student stu : listStudent) {
ArrayList<ChooseCourse> stuCourseSelects = getStudentSelects(stu.getId());
if (!stuCourseSelects.isEmpty()) {
System.out.println(stu.getId() + " " + stu.getStuName() + " " + getAvgTotalScore(stuCourseSelects));
} else {
System.out.println(stu.getId() + " " + stu.getStuName() + " did not take any exams");
}
}
}
public void showCourses() {
Collections.sort(listCourse);
for (Course course : listCourse) {
ArrayList<ChooseCourse> stuCourseSelects = getCourseSelects(course.getCourseName());
if (!stuCourseSelects.isEmpty()) {
if (course.getTestType().equals("考试")) {
System.out.println(
course.getCourseName() + " " + getAvgUsualScore(stuCourseSelects) + " "
+ getAvgFinalScore(stuCourseSelects) + " " + getAvgTotalScore(stuCourseSelects));
}
if (course.getTestType().equals("考察")) {
System.out.println(
course.getCourseName() + " " + getAvgFinalScore(stuCourseSelects) + " "
+ getAvgTotalScore(stuCourseSelects));
}
} else {
System.out.println(course.getCourseName() + " has no grades yet");
}
}
}
public void showClasses() {
Collections.sort(listClass);
for (Class cls : listClass) {
ArrayList<ChooseCourse> stuCourseSelects = getClassSelects(cls.getClassId());
if (!stuCourseSelects.isEmpty()) {
System.out.println(cls.getClassId() + " " + getAvgTotalScore(stuCourseSelects));
} else {
System.out.println(cls.getClassId() + " has no grades yet");
}
}
}
public ArrayList<ChooseCourse> getStudentSelects(String id) {
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse cos : listChooseCourse) {
if (cos.student.getId().equals(id)) {
choose.add(cos);
}
}
return choose;
}
public ArrayList<ChooseCourse> getCourseSelects(String courseName) {
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse cos : listChooseCourse) {
if (cos.course.getCourseName().equals(courseName)) {
choose.add(cos);
}
}
return choose;
}
public ArrayList<ChooseCourse> getClassSelects(String clsId) {
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse cos : listChooseCourse) {
if (cos.student.getClsId().equals(clsId)) {
choose.add(cos);
}
}
return choose;
}
public int getAvgTotalScore(ArrayList<ChooseCourse> cs) {
int sum = 0;
for (ChooseCourse c : cs) {
sum += c.grade.getTotalGrade();
}
return cs.isEmpty() ? 0 : sum / cs.size();
}
public int getAvgUsualScore(ArrayList<ChooseCourse> cs) {
int sum = 0;
for (ChooseCourse c : cs) {
if (c.course.getTestType().equals("考试")) {
sum += c.grade.getUsualGrade();
}
}
return cs.isEmpty() ? 0 : sum / cs.size();
}
public int getAvgFinalScore(ArrayList<ChooseCourse> cs) {
int sum = 0;
for (ChooseCourse c : cs) {
sum += c.grade.finalGrade;
}
return cs.isEmpty() ? 0 : sum / cs.size();
}
}
class ChooseCourse {
Course course;
Student student;
Grade grade;
public ChooseCourse(Course course, Student student, Grade grade) {
this.course = course;
this.student = student;
this.grade = grade;
}
}
class Student implements Comparable<Student> {
String stuName;
String id;
String clsId;
public String getId() {
return id;
}
public String getStuName() {
return stuName;
}
public String getClsId() {
return clsId;
}
public Student(String clsId, String id, String stuName) {
this.clsId = clsId;
this.id = id;
this.stuName = stuName;
}
public int compareTo(Student stu) {
return getId().compareTo(stu.getId());
}
}
class Course implements Comparable<Course> {
String courseName;
String type;
String testType;
public Course() {
}
public Course(String courseName, String type, String testType) {
this.courseName = courseName;
this.type = type;
this.testType = testType;
}
public String getCourseName() {
return courseName;
}
public String getType() {
return type;
}
public String getTestType() {
return testType;
}
@Override
public int compareTo(Course o) {
Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
return compare.compare(courseName, o.getCourseName());
}
}
class Class implements Comparable<Class> {
String classId;
public Class() {
}
public String getClassId() {
return classId;
}
public Class(String classId) {
this.classId = classId;
}
@Override
public int compareTo(Class o) {
return getClassId().compareTo(o.getClassId());
}
}
abstract class Grade {
int finalGrade;
public Grade() {
}
public abstract int getUsualGrade();
public abstract int getTotalGrade();
}
class ExamGrade extends Grade {
int usualGrade;
public ExamGrade(int usualGrade, int finalGrade) {
this.usualGrade = usualGrade;
this.finalGrade = finalGrade;
}
public int getUsualGrade() {
return usualGrade;
}
public int getFinalGrade() {
return 0;
}
public int getTotalGrade() {
return (int) (usualGrade * 0.3 + finalGrade * 0.7);
}
}
class AssessGrade extends Grade {
public AssessGrade(int finalGrade) {
this.finalGrade = finalGrade;
}
public int getFinalGrade() {
return finalGrade;
}
@Override
public int getUsualGrade() {
return 0;
}
public int getTotalGrade() {
return finalGrade;
}
}
class InputMatching {
static String stuNumMatching = "[0-9]{8}";//8个0-9的数字
static String stuNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
static String scoreMatching = "([1-9]?[0-9]|100)";
static String courseNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
static String courseTypeMatching = "(选修|必修)";
static String checkCourseTypeMatching = "(考试|考察)";
//courseInput用于定义课程信息模式（正则表达式）
static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching;
//scoreInput用于定义成绩信息模式（正则表达式）
static String scoreInput1 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
scoreMatching;
static String scoreInput2 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
scoreMatching + " " + scoreMatching;
public InputMatching() {
}
public 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) {
if (s.matches(scoreInput1) || s.matches(scoreInput2)) {
return true;
}
return false;
}
}
测试结果：
代码运行结果：题测4这一测试点并不知道是一个什么样的测试点，该测试点并未通过。也不知道从何修改。考核数据与考核方式不匹配这一测试点也并未通过，编写一个考核数据和考核方式匹配的函数来解决。
心得体会：
首先要将问题分解为不同的模块或类，这有助于更好地组织和管理代码。在这个问题中，可以创建课程类、学生类等模块来处理不同的任务。需要考虑各种异常情况，例如成绩范围超出、课程性质和考核方式不匹配等。合理的异常处理能够提高程序的健壮性。尽量重用代码，避免重复的逻辑。在这个问题中，多个学生可能拥有相同的课程，可以通过创建课程对象并共享它们来减少冗余。面向对象编程的思想有助于更好地组织和管理代码，将问题分解为对象和类，使代码更具可读性和可维护性。
7-7 菜单计价程序-1
分数 30
作者 蔡轲
单位 南昌航空大学
某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9
设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份
不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。
参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}
点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}
订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}
输入格式:
每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。
输出格式:
订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 2
西红柿炒蛋 3
end
输出样例:
在这里给出相应的输出。例如：
48
输入样例1:
订单中包含不存在的菜品记录。例如：
麻婆豆腐 2
炒脆肚 2
西红柿炒蛋 3
end
输出样例1:
在这里给出相应的输出。例如：
炒脆肚 does not exist
48
代码编写如下：
import java.util.Scanner;
class Dish {
String name;
int unit_price;
Dish(String name, int unit_price) {
this.name = name;
this.unit_price = unit_price;
}
int getPrice(int portion) {
double price = unit_price;
if (portion == 2) {
price *= 1.5;
} else if (portion == 3) {
price *= 2;
}
return (int) Math.round(price);
}
}
class Menu {
Dish[] dishes;
Menu() {
dishes = new Dish[4];
dishes[0] = new Dish("西红柿炒蛋", 15);
dishes[1] = new Dish("清炒土豆丝", 12);
dishes[2] = new Dish("麻婆豆腐", 12);
dishes[3] = new Dish("油淋生菜", 9);
}
Dish searchDish(String dishName) {
for (Dish dish : dishes) {
if (dish.name.equals(dishName)) {
return dish;
}
}
return null;
}
}
class Record {
Dish dish;
int portion;
Record(Dish dish, int portion) {
this.dish = dish;
this.portion = portion;
}
int getPrice() {
return dish.getPrice(portion);
}
}
class Order {
Record[] records;
int total_price;
Order() {
records = new Record[100];
total_price = 0;
}
int getTotalPrice() {
int total = 0;
for (Record record : records) {
if (record != null) {
total += record.getPrice();
}
}
return total;
}
Record addARecord(String dishName, int portion) {
Menu menu = new Menu();
Dish dish = menu.searchDish(dishName);
if (dish == null) {
System.out.println(dishName + " does not exist");
return null;
} else {
Record record = new Record(dish, portion);
for (int i = 0; i < records.length; i++) {
if (records[i] == null) {
records[i] = record;
break;
}
}
return record;
}
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Order order = new Order();
while (true) {
String input = scanner.nextLine();
if (input.equals("end")) {
break;
}
String[] parts = input.split(" ");
String dishName = parts[0];
int portion = Integer.parseInt(parts[1]);
order.addARecord(dishName, portion);
}
System.out.println(order.getTotalPrice());
scanner.close();
}
}
测试结果：
心得体会：
首先，将问题分解为不同的模块或类，这有助于更好地组织和管理代码。在这个问题中，可以创建菜品类、菜谱类、点菜记录类、订单类等模块来处理不同的任务。在Java中，类是面向对象编程的基础，需要定义合适的类来表示问题中的不同概念。在这个问题中，菜品类可以包含菜品名称和单价，订单类可以包含订单上的所有点菜记录，点菜记录类可以包含菜品和份额等信息。考虑各种异常情况，例如不能识别的菜名、无效的份额等。合理的异常处理可以提高程序的健壮性。计算菜品价格时需要根据份额进行不同的计算，同时需要考虑四舍五入的规则。在Java中，可以使用整数类型进行计算，然后将结果四舍五入到整数部分。编写测试用例并进行逐步调试是非常重要的。在处理复杂问题时，很容易出现逻辑错误，因此测试和调试是解决问题的关键步骤。
踩坑心得：
第一次提交作业时，类的定义缺少了MAIN类，导致程序报错。有的时候代码逻辑混乱导致无法通过，当自己想要对其改写时，面对混乱的代码逻辑时，无法对其改错，进而对代码重新编写。逐步调试能力弱。在处理复杂问题时，很容易出现逻辑错误，在面对这种情况这种情况时，只能选择重新编写代码。无参构造和有参构造这两种构造方法有严格的使用规定，必须按照相应的规则来构造函数。有的代码中没有提供输入格式的定义，因此无法确定输入数据的格式是否与要求的格式一致。如果输入数据的格式与代码要求的格式不一致，也会导致代码无法正常运行。
主要困难：
对于Java的面向对象设计编程框架还不够熟悉。编译过程中还存在着对象不够明确，未能将处理对象的方法封装在一个类中。不能够自己优化自己编写的代码，有的时候代码编写的长度过长，有的代码时间运行时间过长。
总结：
初步了解了Java与C语言的共性与不同，学到了很多关于Java编程语言的知识，包括基本语法、面向对象编程、异常处理、框架等。这三次作业的难度梯度对于我来说跨度有些大，可能是由于初次接触面对对象的编程语言。其他的课程也比较多，我没有很好的去分配时间来完成各个课程的作业。通过这三次作业和课程中的实验，对Java的运用更加熟练，同时也提高了自己的编程能力。在学习过程中，我也发现了很多需要进一步学习和研究的地方。希望在接下来的学习中能够完成我想要达成的目标。
浙公网安备 33010602011771号