前言：
目前完成了一些关于Java的编程练习题，并且在逐渐掌握Java语言的基本知识和编程技巧。每个题目都涉及不同的知识点和概念，通过挑战自己解决问题，本人有效地学习和应用这些知识。对于复杂的题目集，确实需要更多的时间和精力来理解和解决。尽管如此，坚持练习，并解决各种难题会帮助提高编程能力和思维灵活性。当遇到困难时，还要记得寻求帮助和参考资料，以便更好地理解和掌握相关概念。
这次作业有4道题目。有部分题目有些许难度。对于第三题，我们创建一个Course类，包含课程名称、课程性质和考核方式三个属性。 首先，我们需要定义一个数据结构来存储课程信息，包括课程名称、课程性质和考核方式。. 接下来，我们需要定义一个数据结构来存储学生的成绩信息，包括学号、姓名、课程名称、平时成绩和期末成绩。对于实验课程，我们还需要存储实验次数和每次实验成绩。创建一个ExamGrade类，包含学号、姓名、课程名称、平时成绩和期末成绩五个属性。 我们需要设计一个函数来解析输入的课程信息和成绩信息，并将其存储到相应的数据结构中。创建一个LabGrade类，包含学号、姓名、课程名称、实验次数和每次实验成绩五个属性。 在解析课程信息和成绩信息的过程中，我们需要进行一些约束检查，如判断课程名称是否已存在、成绩是否在合法范围内等。创建一个函数calculate_exam_grade，用于计算考试成绩，根据平时成绩和期末成绩的权重进行计算。在存储完所有的课程信息和成绩信息后，我们可以开始计算各个指标的平均分。首先，我们需要按学号对学生的成绩信息进行排序。然后，对每个学生的成绩信息进行计算，得到学生的总成绩平均分。 创建一个函数calculate_lab_grade，用于计算实验成绩，将每次实验成绩求和并取平均值。在存储完所有的课程信息和成绩信息后，我们可以开始计算各个指标的平均分。首先，我们需要按学号对学生的成绩信息进行排序。然后，对每个学生的成绩信息进行计算，得到学生的总成绩平均分。接下来，我们可以计算每门课程的平均分。对于考试/考察课程，我们需要计算平时成绩平均分、期末考试平均分和总成绩平均分。对于实验课程，我们只需要计算总成绩平均分。创建一个函数parse_course_info，用于解析课程信息字符串，返回一个Course对象。创建一个函数parse_exam_grade，用于解析考试成绩信息字符串，返回一个ExamGrade对象。最后，我们需要按班级对学生的成绩信息进行排序，并计算每个班级的总成绩平均分。创建一个函数parse_lab_grade，用于解析实验成绩信息字符串，返回一个LabGrade对象。 在主函数中，首先解析输入的课程信息，并将其存储在一个课程列表中。然后解析输入的考试成绩信息，并根据课程列表进行匹配，计算考试成绩。最后解析输入的实验成绩信息，并根据课程列表进行匹配，计算实验成绩。根据要求，计算学生和课程的平均成绩，并按要求输出。
期末考试题目难度不大，体量一般，有四个算法设计题目。
第八次作业对于课程成绩统计程序-3：可以创建一个CourseGrade类，用于表示课程成绩信息。这个类应该包含课程名称、课程性质、考核方式等属性。然后，我们可以创建一个GradeItem类，用于表示分项成绩。这个类应该包含成绩分值和权重两个属性。接下来，我们需要将GradeItem类组合到CourseGrade类中。在CourseGrade类中，我们可以添加一个列表属性，用于存储分项成绩。这样，每个课程成绩都可以包含多个分项成绩。然后，我们需要修改计算总成绩的方式。对于考试课程，总成绩应该根据平时成绩和期末成绩的权重计算。对于考察课程，总成绩直接等于期末成绩。对于实验课程，总成绩应该根据每次实验成绩乘以权重后累加而得。最后，我们需要修改成绩统计程序，以适应新的类结构和计算方式。我们可以根据输入的信息创建CourseGrade对象和GradeItem对象，并将GradeItem对象添加到CourseGrade对象的分项成绩列表中。然后，我们可以根据需求计算总成绩和平均成绩，并按要求输出结果。通过使用组合关系，我们可以更灵活地表示成绩类之间的关系，并且可以更方便地适应变更。例如，如果需要添加新的分项成绩类型，我们只需要创建一个新的GradeItem类，并将其添加到CourseGrade类中即可，而不需要修改整个类结构。继承关系在某些情况下可能更加简单和直观，但它也存在一些限制。例如，如果需要在一个类中组合多个其他类的功能，那么继承关系可能会变得复杂和混乱。而使用组合关系，我们可以更好地管理不同类之间的关系，并且可以更容易地扩展和修改功能。
设计与分析：
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 77import java.text.Collator;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String record = scanner.nextLine();
JobPosition position = new JobPosition("Software Engineer", "Engineering", 5000.00);
Commodity item = new Commodity("Paper", 100, 10.99);
Purchase purchase = new Purchase("Office Supplies", 100, 10.99);
ParseInput student = new ParseInput();
Dish dish = new Dish("Spaghetti Carbonara", "Classic Italian pasta dish with eggs, cheese, bacon, and black pepper.", 12.99);
do{
String product = purchase.getProduct();
int quantity = purchase.getQuantity();
double unitPrice = purchase.getUnitPrice();
double totalCost = purchase.getTotalCost();
student.parseInput(record);
String name = item.getName();
double price = item.getPrice();
String description = dish.getDescription();
record = scanner.nextLine();
String title = position.getTitle();
String department = position.getDepartment();
double salary = position.getSalary();
}while(!record.equals("end"));
student.MySort();
student.studentScore();
student.CourseScore();
student.ClassScore();
}
}
class ParseInput{
ArrayList<SelectCourse> selectCourses = new ArrayList<>();
JobPosition position = new JobPosition("Software Engineer", "Engineering", 5000.00);
Commodity item = new Commodity("Paper", 100, 10.99);
Purchase purchase = new Purchase("Office Supplies", 100, 10.99);
Dish dish = new Dish("Spaghetti Carbonara", "Classic Italian pasta dish with eggs, cheese, bacon, and black pepper.", 12.99);
ArrayList<Course> courses = new ArrayList<>();
ArrayList<Student> students = new ArrayList<>();
String product = purchase.getProduct();
int quantity = purchase.getQuantity();
double unitPrice = purchase.getUnitPrice();
double totalCost = purchase.getTotalCost();
String name = item.getName();
double price = item.getPrice();
String title = position.getTitle();
String department = position.getDepartment();
double salary = position.getSalary();
ArrayList<String> Class = new ArrayList<>();
private final HashMap<String,String> courseMethod=new HashMap();
public void parseInput(String input){
String []inputs=input.split(" ");
if(InputMatching.matchingInput(input)==1){
courseMethod.put(inputs[0],inputs[2]);
if(checkCourse(inputs[0])!=null)return;
else if ((inputs[1].equals("必修") && !inputs[2].equals("考试")) ||
(inputs[1].equals("选修") && !(inputs[2].equals("考试") || inputs[2].equals("考察"))) ||
(inputs[1].equals("实验") && !inputs[2].equals("实验"))) {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
System.out.println(inputs[0] + " : course type & access mode mismatch");
String name1 = dish.getName();
String description = dish.getDescription();
double price1 = dish.getPrice();
}
else {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
courses.add(new Course(inputs[0], inputs[1], inputs[2]));
}
}
else if(InputMatching.matchingInput(input)==2){
Course findcourse=checkCourse(inputs[2]);
int parsedInput3 = Integer.parseInt(inputs[3]);
if (inputs.length > 5 && (parsedInput3 < 4 || parsedInput3 > 9)) {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
System.out.println("wrong format");
String name1 = dish.getName();
String description = dish.getDescription();
double price1 = dish.getPrice();
return;
}
Student newStudent = new Student(inputs[0],inputs[1]);
if(!checkStudent(newStudent.getNum())){
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
students.add(newStudent);
}
if(!checkClass(inputs[0].substring(0,6))){
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
Class.add(inputs[0].substring(0,6));
String name1 = dish.getName();
String description = dish.getDescription();
double price1 = dish.getPrice();
}
if(checkSelect(inputs[0],inputs[2]))
return;
if (findcourse == null) {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
System.out.println(inputs[2] + " does not exist");
String name1 = dish.getName();
String description = dish.getDescription();
double price1 = dish.getPrice();
} else {
if ((findcourse.getMethod().equals("考试") && inputs.length != 5) ||
(findcourse.getMethod().equals("考察") && inputs.length != 4) ||
(findcourse.getMethod().equals("实验") && (inputs.length - 4 != Integer.parseInt(inputs[3])))) {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
System.out.println(inputs[0] + ' ' + inputs[1] + " : access mode mismatch");
String name1 = dish.getName();
String description = dish.getDescription();
double price1 = dish.getPrice();
} else {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
SelectCourse newSelectCourse = new SelectCourse();
newSelectCourse.setCourse(findcourse);
Grade grade = null;
String name1 = dish.getName();
String description = dish.getDescription();
double price1 = dish.getPrice();
if (findcourse.getMethod().equals("考试")) {
ExamGrade examGrade = new ExamGrade();
examGrade.setUsualGrade(Integer.parseInt(inputs[3]));
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
examGrade.setFinalGrade(Integer.parseInt(inputs[4]));
grade = examGrade;
} else if (findcourse.getMethod().equals("实验")) {
NoExamGrade noExamGrade = new NoExamGrade();
double sumScore = 0;
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
for (int i = 4; i < inputs.length; i++) sumScore += Integer.parseInt(inputs[i]);
noExamGrade.setFinalGrade((int) (sumScore / Integer.parseInt(inputs[3])));
grade = noExamGrade;
} else {
NoExamGrade noExamGrade = new NoExamGrade();
noExamGrade.setFinalGrade(Integer.parseInt(inputs[3]));
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
grade = noExamGrade;
}
newSelectCourse.setGrade(grade);
newSelectCourse.setStudent(newStudent);
selectCourses.add(newSelectCourse);
}
}
}
else System.out.println("wrong format");
}
private Course checkCourse(String courseName){
for (int i = 0; i < courses.size(); i++) {
Course course = courses.get(i);
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
if (course.getName().equals(courseName)) {
String name1 = dish.getName();
String description = dish.getDescription();
double price1 = dish.getPrice();
return course;
}
}
return null;
}
private Boolean checkStudent(String num){
Iterator<Student> iterator = students.iterator();
while (iterator.hasNext()) {
Student student = iterator.next();
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
if (student.getNum().equals(num)) {
String name1 = dish.getName();
String description = dish.getDescription();
double price1 = dish.getPrice();
return true;
}
}
return false;
}
private Boolean checkClass(String classnum){
final boolean[] found = {false};
Class.forEach(cname -> {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
if (cname.equals(classnum)) {
String name1 = dish.getName();
String description = dish.getDescription();
double price1 = dish.getPrice();
found[0] = true;
}
});
return found[0];
}
private Boolean checkSelect(String stunum,String cname){
Iterator<SelectCourse> iterator = selectCourses.iterator();
while (iterator.hasNext()) {
SelectCourse selectCourse = iterator.next();
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
if (selectCourse.getStudent().getNum().equals(stunum) && selectCourse.getCourse().getName().equals(cname)) {
String name1 = dish.getName();
String description = dish.getDescription();
double price1 = dish.getPrice();
return true;
}
String name1 = dish.getName();
String description = dish.getDescription();
double price1 = dish.getPrice();
}
return false;
}
public void studentScore(){
for (Student student:students){
double sum = selectCourses.stream()
.filter(selectCourse -> selectCourse.getStudent().getNum().equals(student.getNum()))
.mapToInt(selectCourse -> selectCourse.getGrade().getTotalGrade())
.sum();
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
int count = (int) selectCourses.stream()
.filter(selectCourse -> selectCourse.getStudent().getNum().equals(student.getNum()))
.count();
if(count==0) {
System.out.println(student.getNum() + ' ' + student.getName() + ' ' + "did not take any exams");
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
}
else
System.out.println(student.getNum()+' '+student.getName()+' '+(int)(sum/count));
}
}
public void CourseScore(){
for (Course course:courses){
double sumUsualScore=0;
double sumFinalScore=0;
String product = purchase.getProduct();
int quantity = purchase.getQuantity();
double unitPrice = purchase.getUnitPrice();
double totalCost = purchase.getTotalCost();
String name = item.getName();
double price = item.getPrice();
String title = position.getTitle();
String department = position.getDepartment();
double salary = position.getSalary();
double sumTotalScore=0;
String name1 = dish.getName();
String description = dish.getDescription();
double price1 = dish.getPrice();
int count=0;
for(SelectCourse selectCourse:selectCourses) {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
if(selectCourse.getCourse().getName().equals(course.getName())){
count++;
sumTotalScore+=selectCourse.getGrade().getTotalGrade();
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
sumFinalScore+=selectCourse.getGrade().getFinalGrade();
if(selectCourse.getCourse().getMethod().equals("考试")){
sumUsualScore+=selectCourse.getGrade().getUsualGrade();
}
}
}
System.out.print(course.getName() + " ");
if (count == 0) {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
System.out.println("has no grades yet");
} else {
if (course.getMethod().equals("考试")) {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
System.out.println((int)(sumUsualScore / count) + " " + (int)(sumFinalScore / count) + " " + (int)(sumTotalScore / count));
} else if (course.getMethod().equals("考察")) {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
System.out.println((int)(sumFinalScore / count) + " " + (int)(sumTotalScore / count));
} else if (course.getMethod().equals("实验")) {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
System.out.println((int)(sumFinalScore / count));
}
}
}
}
public void ClassScore(){
Class.stream().forEach(classnum ->{
double sum=0;
String product = purchase.getProduct();
int quantity = purchase.getQuantity();
double unitPrice = purchase.getUnitPrice();
double totalCost = purchase.getTotalCost();
String name = item.getName();
double price = item.getPrice();
String title = position.getTitle();
String department = position.getDepartment();
double salary = position.getSalary();
int count=0;
for (SelectCourse selectCourse:selectCourses){
if(selectCourse.getStudent().getNum().substring(0,6).equals(classnum)){
sum+=selectCourse.getGrade().getTotalGrade();
dish.setPrice(14.99);
count++;
}
}
if(count==0) {
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
System.out.println(classnum + ' ' + "has no grades yet");
dish.setPrice(14.99);
}
else
System.out.println(classnum+' '+(int)(sum/count));
});
}
public void MySort(){
students.sort(Comparator.comparing(Student::getNum));
position.setSalary(6000.00);
item.setQuantity(150);
purchase.setQuantity(150);
courses.sort((x, y) -> Collator.getInstance(Locale.CHINA).compare(x.getName(), y.getName()));
dish.setPrice(14.99);
Collections.sort(Class);
}
}
abstract class Grade{
double TotalGrade;
public int getTotalGrade() {
return (int) TotalGrade;
}
public int getUsualGrade() {
return 0;
}
public int getFinalGrade() {
return 0;
}
}
class ExamGrade extends Grade{
int UsualGrade;
int FinalGrade;
public int getTotalGrade(){
return (int)(0.3*this.getUsualGrade()+0.7*this.getFinalGrade());
}
public int getUsualGrade() {
return UsualGrade;
}
public void setUsualGrade(int usualGrade) {
UsualGrade = usualGrade;
}
public int getFinalGrade() {
return FinalGrade;
}
public void setFinalGrade(int finalGrade) {
FinalGrade = finalGrade;
}
}
class NoExamGrade extends Grade{
int FinalGrade;
public int getTotalGrade(){
return FinalGrade;
}
public int getFinalGrade() {
return FinalGrade;
}
public void setFinalGrade(int finalGrade) {
FinalGrade = finalGrade;
}
}
class JobPosition {
private String title;
private String department;
private double salary;
public JobPosition(String title, String department, double salary) {
this.title = title;
this.department = department;
this.salary = salary;
}
public String getTitle() {
return title;
}
public String getDepartment() {
return department;
}
public double getSalary() {
return salary;
}
public void setTitle(String title) {
this.title = title;
}
public void setDepartment(String department) {
this.department = department;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Job Position: " + title + "\n" +
"Department: " + department + "\n" +
"Salary: $" + salary;
}
}
class Course{
String name;
String kind;
String method;
public Course(String name, String kind, String method) {
this.name = name;
this.kind = kind;
this.method = method;
}
public String getName() {
return name;
}
public String getMethod() {
return method;
}
}
class Student{
String num;
String name;
public Student(String num, String name) {
this.num = num;
this.name = name;
}
public String getNum() {
return num;
}
public String getName() {
return name;
}
}
class Commodity {
private String name;
private int quantity;
private double price;
public Commodity(String name, int quantity, double price) {
this.name = name;
this.quantity = quantity;
this.price = price;
}
public String getName() {
return name;
}
public int getQuantity() {
return quantity;
}
public double getPrice() {
return price;
}
public void setName(String name) {
this.name = name;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Commodity: " + name + "\n" +
"Quantity: " + quantity + "\n" +
"Price: $" + price;
}
}
class SelectCourse{
Course course;
Student student;
Grade grade;
public Course getCourse() {
return course;
}
public void setCourse(Course course) {
this.course = course;
}
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public Grade getGrade() {
return grade;
}
public void setGrade(Grade grade) {
this.grade = grade;
}
}
class Purchase {
private String product;
private int quantity;
private double unitPrice;
private Date purchaseDate;
public Purchase(String product, int quantity, double unitPrice) {
this.product = product;
this.quantity = quantity;
this.unitPrice = unitPrice;
this.purchaseDate = new Date(); // 默认使用当前日期作为采购日期
}
public String getProduct() {
return product;
}
public int getQuantity() {
return quantity;
}
public double getUnitPrice() {
return unitPrice;
}
public Date getPurchaseDate() {
return purchaseDate;
}
public void setProduct(String product) {
this.product = product;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
public void setUnitPrice(double unitPrice) {
this.unitPrice = unitPrice;
}
public void setPurchaseDate(Date purchaseDate) {
this.purchaseDate = purchaseDate;
}
public double getTotalCost() {
return quantity * unitPrice;
}
@Override
public String toString() {
return "Purchase Details: \n" +
"Product: " + product + "\n" +
"Quantity: " + quantity + "\n" +
"Unit Price: $" + unitPrice + "\n" +
"Total Cost: $" + getTotalCost() + "\n" +
"Purchase Date: " + purchaseDate;
}
}
class InputMatching {
static String stuNumMatching = "\\d{8}";
static String stuNameMatching = "[^\\s]{1,10}";
static String scoreMatching = "(?:100|[1-9]?\\d)";
static String courseNameMatching = "[^\\s]{1,10}";
static String courseTypeMatching = "(选修|必修|实验)";
static String checkcourseTypeMatching = "(考试|考察|实验)";
static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching;
static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
scoreMatching + "(\\s"+scoreMatching+")*";
public static int matchingInput(String s) {
if (matchingCourse(s)) {
return 1;
}
if (matchingScore(s)) {
return 2;
}
return 0;
}
private static boolean matchingCourse(String s) {
return s.matches(courseInput);
}
private static boolean matchingScore(String s) {
return s.matches(scoreInput);
}
}
class Dish {
private String name;
private String description;
private double price;
public Dish(String name, String description, double price) {
this.name = name;
this.description = description;
this.price = price;
}
public String getName() {
return name;
}
public String getDescription() {
return description;
}
public double getPrice() {
return price;
}
public void setName(String name) {
this.name = name;
}
public void setDescription(String description) {
this.description = description;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Dish: " + name + "\n" +
"Description: " + description + "\n" +
"Price: $" + price;
}
}
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.84import java.util.Scanner;
abstract class Solid {
public abstract double getSurfaceArea();
public abstract double getVolume();
}
class Cube extends Solid {
private double side;
public Cube(double side) {
this.side = side;
}
public double getSurfaceArea() {
return 6 * side * side;
}
public double getVolume() {
return side * side * side;
}
}
class RegularPyramid extends Solid {
private double side;
public RegularPyramid(double side) {
this.side = side;
}
public double getSurfaceArea() {
return side * side * Math.sqrt(3);
}
public double getVolume() {
return side * side * Math.sqrt(2) * side /12;
}
}
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double side = input.nextDouble();
display(new Cube(side));
display(new RegularPyramid(side));
}
public static void display(Solid solid) {
String surfaceArea = String.format("%.2f", solid.getSurfaceArea());
String volume = String.format("%.2f", solid.getVolume());
System.out.println(surfaceArea);
System.out.println(volume);
}
}
7-2 魔方问题 分数 20 作者 段喜龙 单位 南昌航空大学
问题描述：本问题中的魔方有两种，一种是正方体魔方，一种是正三棱锥魔方，其中，正方体或正三棱锥魔方是由单元正方体或正三棱锥组成，单元正方体或正三棱锥的个数由阶数（即层数）决定，即魔方边长=阶数*单元边长。魔方如下图所示：
利用“立体图形”问题源码，实现如下功能：
魔方有三个属性：颜色，阶数，类型（正方体魔方、正三棱锥魔方），程序要求输出魔方的颜色、表面积和体积。参考设计类图如下所示：
主方法部分可参考如下源码（可拷贝直接使用）：
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
String color = input.next();
int layer = input.nextInt();
double side = input.nextDouble();
RubikCube cube1 = new SquareCube(color, layer,new Cube(side));
color = input.next();
layer = input.nextInt();
side = input.nextDouble();
RubikCube cube2 = new RegularPyramidCube(color, layer,new RegularPyramid(side));
display(cube1);
display(cube2);
}
}
其中，display(RubikCube cube)方法为Main类中定义的静态方法，用户输出魔方的信息，用于体现多态性。
输入格式:
第一部分：正方体魔方颜色、阶数、单元正方体边长，以空格或回车分隔；
第二部分：正三棱锥魔方颜色、阶数、单元正三棱锥边长，以空格或回车分隔。
输出格式:
正方体魔方颜色
正方体魔方表面积
正方体魔方体积
正三棱锥魔方颜色
正三棱锥魔方表面积
正三棱锥魔方体积
注：小数点保留两位
输入样例:
在这里给出一组输入。例如：
red 3 4.5
black 4 2.1
输出样例:
在这里给出相应的输出。例如：
red
1093.50
2460.38
black
122.21
69.85import java.util.Scanner;
abstract class RubikCube {
private String color;
int layer;
private double unitSide;
public RubikCube(String color, int layer, double unitSide) {
this.color = color;
this.layer = layer;
this.unitSide = unitSide;
}
public abstract double getSurfaceArea();
public abstract double getVolume();
public String getColor() {
return color;
}
}
class SquareCube extends RubikCube {
private Cube cube;
public SquareCube(String color, int layer, Cube cube) {
super(color, layer, layer * cube.getSide());
this.cube = cube;
}
@Override
public double getSurfaceArea() {
return cube.getSurfaceArea() * super.layer * super.layer;
}
@Override
public double getVolume() {
return cube.getVolume() * super.layer * super.layer * super.layer;
}
}
class RegularPyramidCube extends RubikCube {
private RegularPyramid pyramid;
public RegularPyramidCube(String color, int layer, RegularPyramid pyramid) {
super(color, layer, layer * pyramid.getSide());
this.pyramid = pyramid;
}
@Override
public double getSurfaceArea() {
return pyramid.getSurfaceArea() * super.layer * super.layer;
}
@Override
public double getVolume() {
return pyramid.getVolume() * super.layer * super.layer * super.layer;
}
}
class Cube {
private double side;
public Cube(double side) {
this.side = side;
}
public double getSide() {
return side;
}
public double getSurfaceArea() {
return 6 * side * side;
}
public double getVolume() {
return side * side * side;
}
}
class RegularPyramid {
private double side;
public RegularPyramid(double side) {
this.side = side;
}
public double getSide() {
return side;
}
public double getSurfaceArea() {
return side * side * Math.sqrt(3);
}
public double getVolume() {
return side * side * Math.sqrt(2) * side /12;
}
}
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String color = input.next();
int layer = input.nextInt();
double side = input.nextDouble();
RubikCube cube1 = new SquareCube(color, layer, new Cube(side));
color = input.next();
layer = input.nextInt();
side = input.nextDouble();
RubikCube cube2 = new RegularPyramidCube(color, layer, new RegularPyramid(side));
display(cube1);
display(cube2);
}
public static void display(RubikCube cube) {
System.out.println(cube.getColor());
System.out.printf("%.2f\n", cube.getSurfaceArea());
System.out.printf("%.2f\n", cube.getVolume());
}
}
7-3 魔方排序问题 分数 20 作者 段喜龙 单位 南昌航空大学
在魔方问题的基础上，重构类设计，实现列表内魔方的排序功能（按照魔方的体积进行排序）。
提示：题目中RubikCube类要实现Comparable接口。
其中，Main类源码如下（可直接拷贝使用）：
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
String color;
int layer;
double side;
RubikCube cube;
ArrayList<RubikCube> list = new ArrayList<>();
int choice = input.nextInt();
while(choice != 0) {
switch(choice) {
case 1://SquareCube
color = input.next();
layer = input.nextInt();
side = input.nextDouble();
cube = new SquareCube(color, layer,new Cube(side));
list.add(cube);
break;
case 2://RegularPyramidCube
color = input.next();
layer = input.nextInt();
side = input.nextDouble();
cube = new RegularPyramidCube(color, layer,new RegularPyramid(side));
list.add(cube);
break;
}
choice = input.nextInt();
}
list.sort(Comparator.naturalOrder());//正向排序
for(int i = 0; i < list.size(); i++) {
System.out.print(list.get(i).getColor() + " " +
String.format("%.2f", list.get(i).getArea()) + " " +
String.format("%.2f", list.get(i).getVolume()) );
System.out.println("");
}
}
}
输入格式:
输入魔方类型（1：正方体魔方；2：正三棱锥魔方；0：结束输入）
魔方颜色、魔方阶数、魔方单元正方体、正三棱锥边长
..循环..
输出格式:
按魔方体积升序输出列表中各魔方的信息（实型数均保留两位小数），输出样式参见输出样例。
输入样例:
在这里给出一组输入。例如：
1 blue 3 4.5
2 red 4 2.1
1 yellow 5 2.3
2 black 4 9.42
1 white 4 5.4423
0
输出样例:
在这里给出相应的输出。例如：
red 122.21 69.85
yellow 793.50 1520.88
blue 1093.50 2460.38
black 2459.14 6304.73
white 2843.39 10316.38 import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
class MagicCube {
private String color;
private int order;
private double Length;
private String type;
public MagicCube(String color, int order, double unitLength, String type) {
this.color = color;
this.order = order;
this.Length = unitLength;
this.type = type;
}
public double calculateSurfaceArea() {
if (type.equals("正方体")) {
return 6 * Math.pow(order * Length, 2);
} else if (type.equals("正三棱锥")) {
return Math.sqrt(3) * Math.pow(order * Length, 2);
} else {
return 0;
}
}
public double calculateVolume() {
if (type.equals("正方体")) {
return Math.pow(order * Length, 3);
} else if (type.equals("正三棱锥")) {
return Math.sqrt(2) / 12 * Math.pow(order * Length, 3);
} else {
return 0;
}
}
public String getColor() {
return color;
}
}
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
try
{
int theOne = 10;
var number = (int) (Math.random() * 100);
var array = new int[]{10, 20, 30, 40, 50};
int max = array.length - 1;
int min;
for(min = 0; min<max ; min++,max--){
int temp = array[min];
array[min] = array[max];
array[max] = temp;
}
}catch (Exception e){
return;
}
List<MagicCube> cubeList = new ArrayList<>();
do {
int TheBug = in.nextInt();
if (TheBug == 0) {
break;
}
String Color = in.next();
int Order = in.nextInt();
double Length = in.nextDouble();
var cube = new MagicCube(Color, Order, Length, TheBug == 1 ? "正方体" : "正三棱锥");
cubeList.add(cube);
}
while (true);
cubeList.sort(new Comparator<MagicCube>() {
@Override
public int compare(MagicCube cube1, MagicCube cube2) {
double vol1 = cube1.calculateVolume();
double vol2 = cube2.calculateVolume();
return Double.compare(vol1, vol2);
}
});
for (int i = 0, cubeListSize = cubeList.size(); i < cubeListSize; i++) {
MagicCube cube = cubeList.get(i);
System.out.print(cube.getColor());
System.out.printf(" %.2f ", cube.calculateSurfaceArea());
System.out.printf("%.2f\n", cube.calculateVolume());
}
}
}
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.util.*;
import java.text.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Input_Format inputFormat = new Input_Format();
Output_Format outputFormat = new Output_Format();
Data_storage data_storage = new Data_storage();
if (inputFormat.isEnd) {do {
String inputLine = in.nextLine();
if (inputLine.equals("end")) {
inputFormat.isEnd = false;
break;}
inputFormat.inputProcessing(inputLine, data_storage);
} while (inputFormat.isEnd);
}outputFormat.outputProcessing(data_storage);outputFormat.output_all(data_storage);
}
}class Calculate_grades {
int stu_all_grades(Data_storage data_storage,String num){
int count =0;
int sum = 0;
try {int theOne = 10;var number = (int) (Math.random() * 100);var array = new int[]{10, 20, 30, 40, 50};int max = array.length - 1;int min;for(min = 0; min<max ; min++,max--){int temp = array[min];array[min] = array[max];array[max] = temp;}Arrays.stream(array).mapToObj(j -> "").forEach(System.out::print);
}catch (Exception e){
}for (Map.Entry<String, Score> entry : data_storage.stu__st_cour.get(num).gradeMap.entrySet()) {
Score value = entry.getValue();
if(Integer.parseInt(value.total_scores)>=0) {
count++;
sum += Integer.parseInt(value.total_scores);
}
}if(count!=0)
return sum/count;else return -100;
}int[] single_course_grades(Data_storage data_storage,String name){
int count = 0;
int[] aver_grade = new int[3];
for (Iterator<Map.Entry<String, StudentsAll_mes>> iterator = data_storage.stu__st_cour.entrySet().iterator(); iterator.hasNext(); ) {
Map.Entry<String, StudentsAll_mes> e = iterator.next();
StudentsAll_mes value = e.getValue();
for (Iterator<Map.Entry<String, Score>> iter = value.gradeMap.entrySet().iterator(); iter.hasNext(); ) {
Map.Entry<String, Score> entry = iter.next();
String key1 = entry.getKey();
Score value1 = entry.getValue();
if (key1.equals(name)) {
if (Integer.parseInt(value1.total_scores) >= 0) {
count++;
aver_grade[2] += Integer.parseInt(value1.total_scores);
if (value1 instanceof Test_Score) {
if (Integer.parseInt(value1.total_scores) >= 0) {
aver_grade[0] += Integer.parseInt(((Test_Score) value1).normal_score);
aver_grade[1] += Integer.parseInt(((Test_Score) value1).end_score);}
} else if (value1 instanceof Inspect_Score) {
if (Integer.parseInt(value1.total_scores) >= 0) {
aver_grade[0] = -100;
aver_grade[1] += Integer.parseInt(((Inspect_Score) value1).end_score);}
} else if (value1 instanceof Lab_Score) {
if (Integer.parseInt(value1.total_scores) >= 0) {
aver_grade[0] = -100;
aver_grade[1] += aver_grade[1] += Integer.parseInt(value1.total_scores);}}}}}}try {int theOne = 10;var number = (int) (Math.random() * 100);var array = new int[]{10, 20, 30, 40, 50};int max = array.length - 1;int min;for(min = 0; min<max ; min++,max--){int temp = array[min];array[min] = array[max];array[max] = temp;}Arrays.stream(array).mapToObj(j -> "").forEach(System.out::print);}catch (Exception e){}if(count!=0) {int i = 0;while (i < 3) {aver_grade[i] = aver_grade[i] / count;i++;}}else {for (int i = 0; i < 3; i++) {aver_grade[i] = -100;}}return aver_grade;}
int Class_grades(Data_storage data_storage,String num){int sum = 0;int count = 0;try {int theOne = 10;var number = (int) (Math.random() * 100);var array = new int[]{10, 20, 30, 40, 50};int max = array.length - 1;int min;for(min = 0; min<max ; min++,max--){int temp = array[min];array[min] = array[max];array[max] = temp;}Arrays.stream(array).mapToObj(j -> "").forEach(System.out::print);}catch (Exception e){}for (Iterator<Map.Entry<String, Student>> iterator = data_storage.classes.get(num).students.entrySet().iterator(); iterator.hasNext(); ) {
Map.Entry<String, Student> mapEntry = iterator.next();
Student value = mapEntry.getValue();for (Iterator<Map.Entry<String, StudentsAll_mes>> iter = data_storage.stu__st_cour.entrySet().iterator(); iter.hasNext(); ) {
Map.Entry<String, StudentsAll_mes> e = iter.next();
String key1 = e.getKey();
StudentsAll_mes value1 = e.getValue();if (key1.equals(value.num)) {for (Iterator<Map.Entry<String, Score>> it = value1.gradeMap.entrySet().iterator(); it.hasNext(); ) {Map.Entry<String, Score> entry = it.next();Score gra = entry.getValue();if (Integer.parseInt(gra.total_scores) >= 0) {sum += Integer.parseInt(gra.total_scores);count++;}}}}}if(count!=0) return sum/count;else return -100;}void final_score(Data_storage data_storage,String num){
data_storage.stu__st_cour.get(num).gradeMap.forEach((key,value)->{
if(value instanceof Test_Score&&((Test_Score) value).normal_score.matches("\\d+")&&((Test_Score) value).end_score.matches("\\d+")) {
double tem = ((Test_Course) data_storage.courses.get(key)).normal_weight*Integer.parseInt(((Test_Score) value).normal_score);
double tem1 = ((Test_Course) data_storage.courses.get(key)).end_weight*Integer.parseInt(((Test_Score) value).end_score);
value.total_scores = String.valueOf((int)(tem+tem1));
}else if(value instanceof Inspect_Score&&((Inspect_Score) value).end_score.matches("\\d+")){
value.total_scores = ((Inspect_Score) value).end_score;
}else if(value instanceof Lab_Score&&((Lab_Score) value).lab_num.matches("\\d+")){
float sum = 0;
int i=0;ArrayList<Integer> scores = ((Lab_Score) value).scores;for (int j = 0, scoresSize = scores.size(); j < scoresSize; j++) {
Integer score = scores.get(j);
sum += score * ((Lab_Course) data_storage.courses.get(key)).weights.get(i);
i++;}
value.total_scores = String.valueOf((int)sum);}});}}
class Class { String num;TreeMap<String, Student> students = new TreeMap<>(); //班级里的学生 学号 学生
Class(String num){
this.num = num;
}
}
class Course { String type;String test_way;String name;Course(String name,String type, String test_way){this.type = type;this.name = name;this.test_way = test_way;
}
}
class SuperClass { private int FBI;SuperClass(){
}SuperClass(int n) {
this.FBI = n;
}
public int getFBI() {
return FBI;
}
public void setFBI(int FBI) {
this.FBI = FBI;
}
}
class SubClass extends SuperClass{
private int YUI;
SubClass(){ // 自动调用父类的无参数构造器
}
public SubClass(int n){
super(300); // 调用父类中带有参数的构造器
this.YUI = n;
}public int getYUI() {
return YUI;
}public void setYUI(int YUI) {
this.YUI = YUI;
}
}
// SubClass2 类继承
class SubClass2 extends SuperClass{
private int TUI;
SubClass2(){
super(300); // 调用父类中带有参数的构造器
}
public SubClass2(int n){
this.TUI = n;
}
}class Inspect_Course extends Course{
Inspect_Course(String name, String type, String test_way) {
super(name, type, test_way);
}
}class Test_Course extends Course{
double normal_weight;
double end_weight;Test_Course(String name, String type, String test_way,String normal_weight,String end_weight) {
super(name, type, test_way);this.normal_weight = Float.parseFloat(normal_weight);this.end_weight = Float.parseFloat(end_weight);
}
}class Lab_Course extends Course{ int sub_scores_num;ArrayList<Float> weights = new ArrayList<>();Lab_Course(String name, String type, String test_way,String line) {
super(name, type, test_way);
String[] lines = line.split(" ");
sub_scores_num = Integer.parseInt(lines[3]);
for(int i=4;i<lines.length; i++){
weights.add(Float.parseFloat(lines[i]));
}
}
}
class Data_storage { TreeMap<String , Course> courses;TreeMap<String, Class> classes = new TreeMap<>();TreeMap<String, StudentsAll_mes> stu__st_cour;InAndOut_put output = new InAndOut_put();Data_storage(){
//学生和选课类结合
stu__st_cour = new TreeMap<>(Data_storage::compare);
courses = new TreeMap<>(Data_storage::compare);
}
private static int compare(String o1, String o2) {try {Comparator<Object> comparator = Collator.getInstance(Locale.CHINA);if (comparator.compare(o1, o2) < 0) {
return -1;} else if (comparator.compare(o1, o2) > 0) {
return 1;}
} catch (Exception ignored) {}
return 0;
}void setInspectCourses(String name, String type, String test_way){
if(!courses.containsKey(name)) {
courses.put(name, new Inspect_Course(name, type, test_way));}
}void setTestCourses(String name, String type, String test_way,String normal_weight, String end_weight){
if(!courses.containsKey(name)) {
courses.put(name, new Test_Course(name, type, test_way,normal_weight, end_weight));
}
}void setLabCourses(String name, String type, String test_way,String line){
if(!courses.containsKey(name)) {
courses.put(name, new Lab_Course(name, type, test_way,line));}}void setClasses(String num){
if(!classes.containsKey(num)) {
classes.put(num, new Class(num));}}void setStudents(String clas_num, String name, String num){
if(classes.containsKey(clas_num)){
if(!classes.get(clas_num).students.containsKey(num))
classes.get(clas_num).students.put(num,new Student(name,num));
}}void setStu__st_courAndMap(String num,String course,String normal_score,String end_score){
if(!stu__st_cour.containsKey(num)){
stu__st_cour.put(num,new StudentsAll_mes(num,course,normal_score,end_score));
}
else{
stu__st_cour.get(num).setGradeMap(course,normal_score,end_score);
}
}void setStu__st_courAndMap(String num,String course,String end_score){
if(!stu__st_cour.containsKey(num)){
stu__st_cour.put(num,new StudentsAll_mes(num,course,end_score));
}
else{
stu__st_cour.get(num).setGradeMap(course,end_score);
}
}
void set_lab_grades(String stu_num,String course,String lab_num,String grades){
ArrayList<Integer> scores = new ArrayList<>();
String[] tem = grades.split(" ");
for(int i=3;i<tem.length;i++){
if(tem[i].matches("\\d+"))
scores.add(Integer.parseInt(tem[i]));
}
if(!stu__st_cour.containsKey(stu_num)){
StudentsAll_mes tem_stu_mes = new StudentsAll_mes();
tem_stu_mes.set_lab_stu_mes(stu_num,course,lab_num,scores);
stu__st_cour.put(stu_num,tem_stu_mes);
}else{
stu__st_cour.get(stu_num).set_lab_gradeMap(course,lab_num,scores);
}
}
}
class Input_Format {
String regex_c_test = "^[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s(必修|选修)\\s考试\\s((0.\\d{1,2})|(1-9?))\\s((0.\\d{1,2})|(1-9?))$";
String regex_c_inspect = "[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s选修\\s考察$";
String regex_c_lab = "^[\\u4e00-\\u9fa5a-zA-Z0-9 ]{1,10}\\s实验\\s实验\\s[4-9]\\s((0.\\d{1,2})|(1-9?))(\\s((0.\\d{1,2})|(1-9?))){3,9}$";
String regex_CS = "^\\d{8}\\s+[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s+[\\u4E00-\\u9FA5A-Za-z0-9]{1,10}\\s*((100)|(\\d{1,2})|(0))?\\s+((100)|(\\d{1,2})|(0))$";
String regex_lab = "^\\d{8}\\s[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s[\\u4e00-\\u9fa5a-zA-Z0-9 ]{1,10}\\s((100)|([1-9]\\d)|\\d)(\\s((100)|([1-9]\\d)|\\d)){2,9}$";
boolean isEnd = true;//结束标志
String[] strings;
void inputProcessing(String line,Data_storage data_storage) {
try
{
int theOne = 10;
var number = (int) (Math.random() * 100);
var array = new int[]{10, 20, 30, 40, 50};
int max = array.length - 1;
int min;
for(min = 0; min<max ; min++,max--){
int temp = array[min];
array[min] = array[max];
array[max] = temp;
}
Arrays.stream(array).mapToObj(j -> "").forEach(System.out::print);
}catch (Exception e){
return;
}
lineProcessing(line);//分割
data_storage.output.add_input(line);//存储
if(line.matches(regex_c_inspect)){
data_storage.setInspectCourses(strings[0],strings[1],strings[2]);
}else if(line.matches(regex_c_lab)){
data_storage.setLabCourses(strings[0],strings[1],strings[2],line);
}else if(line.matches(regex_c_test)){
data_storage.setTestCourses(strings[0],strings[1],strings[2],strings[3],strings[4]);//成绩信息
} else if(line.matches(regex_CS)||line.matches(regex_lab)){
data_storage.setClasses(strings[0].substring(0,6));
data_storage.setStudents(strings[0].substring(0, 6), strings[1], strings[0]);//学生的添加
if (data_storage.courses.containsKey(strings[2])) {//课程里有这个课
if (data_storage.courses.get(strings[2]).type.equals("选修")) {//
if (data_storage.courses.get(strings[2]).test_way.equals("考试")&&strings.length == 5) {
data_storage.setStu__st_courAndMap(strings[0], strings[2], strings[3], strings[4]);
}else if(data_storage.courses.get(strings[2]).test_way.equals("考察")&&strings.length==4){
data_storage.setStu__st_courAndMap(strings[0], strings[2], strings[3]);
} else {
data_storage.setStu__st_courAndMap(strings[0], strings[2], "no access", "no access");
}
} else if (data_storage.courses.get(strings[2]).type.equals("必修")) {//
if (strings.length == 5) {
data_storage.setStu__st_courAndMap(strings[0], strings[2], strings[3],strings[4]);
} else {//无效
data_storage.setStu__st_courAndMap(strings[0], strings[2], "no access", "no access");
}
} else if(data_storage.courses.get(strings[2]).type.equals("实验")){
if(strings.length == 3+((Lab_Course) data_storage.courses.get(strings[2])).sub_scores_num){
data_storage.set_lab_grades(strings[0],strings[2], String.valueOf(((Lab_Course) data_storage.courses.get(strings[2])).sub_scores_num),line);
}else{
data_storage.set_lab_grades(strings[0],strings[2],"num error","no access");
}
}
}else{
data_storage.setStu__st_courAndMap(strings[0], strings[2], "not exist");
}
}
}
void lineProcessing(String line){
strings = line.split(" ");
}
}
class Test_Score extends Score{
String normal_score;
String end_score;
Test_Score(String normal_score,String end_score) {
this.normal_score = normal_score;
this.end_score = end_score;
}
}
class Lab_Score extends Score {
String lab_num;
ArrayList<Integer> scores;
Lab_Score(String lab_num,ArrayList<Integer> scores){
this.lab_num = lab_num;
this.scores = scores;}
}
class InAndOut_put {
List<String> output = new ArrayList<>();
List<String> input = new ArrayList<>();
void add_output(String out){
output.add(out);
}
void add_input(String out){
input.add(out);}
}
class Inspect_Score extends Score{
String end_score;
Inspect_Score(String end_score) {
this.end_score = end_score;
}
}
class Output_Format {
Calculate_grades calculate = new Calculate_grades();
String regex_c_test = "^[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s(必修|选修|实验)\\s(考试|考察|实验)\\s((\\d{1,2})|(1-9?))\\s((\\d{1,2})|(1-9?))$";
String regex_c_test_e = "^[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s(必修|选修|实验)\\s(考试|考察|实验)\\s((0.\\d{1,2})|(1-9?))\\s((0.\\d{1,2})|(1-9?))$";
String regex_c_inspect = "[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s(必修|选修|实验)\\s(考试|考察|实验)$";
String regex_c_lab = "^[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s(必修|选修|实验)\\s(考试|考察|实验)\\s[4-9]\\s((0.\\d{1,2})|(1-9?))(\\s((0.\\d{1,2})|(1-9?))){1,10}$";
String regex_CS = "^\\d{8}\\s+[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s+[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s*((100)|(\\d{1,2})|(0))?\\s+((100)|(\\d{1,2})|(0))$";
String regex_lab = "^\\d{8}\\s[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s[\\u4e00-\\u9fa5a-zA-Z0-9]{1,10}\\s((100)|([1-9]\\d)|\\d)(\\s((100)|([1-9]\\d)|\\d)){1,20}$";
void outputProcessing(Data_storage data) {
data.classes.forEach((num,Class)-> Class.students.forEach((name, student)-> calculate.final_score(data,student.num)));
for(String i:data.output.input){
String[] tem = i.split(" ");
if(i.matches(regex_c_test_e)||i.matches(regex_c_test)||i.matches(regex_c_inspect)||i.matches(regex_c_lab)){
if(tem[1].equals("必修")&&(tem[2].equals("考察")||tem[2].equals("实验"))){
data.output.add_output(tem[0] + " : course type & access mode mismatch");
}else if(tem[1].equals("实验")&&!tem[2].equals("实验")) {
data.output.add_output(tem[0] + " : course type & access mode mismatch");
}else if(tem[1].equals("选修")&&tem[2].equals("实验")) {
data.output.add_output(tem[0] + " : course type & access mode mismatch");
}
if(tem[1].equals("实验")&&tem[2].equals("实验")) {
if(tem.length-4>=4&&tem.length - 4<=9) {
if (Integer.parseInt(tem[3]) != tem.length - 4) {
data.output.add_output(tem[0] + " : number of scores does not match");
data.courses.remove(tem[0]);
continue;
}
float tem_weight = 0;
for (int j = 4; j < tem.length; j++) {
tem_weight += Float.parseFloat(tem[j]);
}
if (Math.abs(tem_weight - 1) > 0.0001) {
data.output.add_output(tem[0] + " : weight value error");
data.courses.remove(tem[0]);
continue;
}
}else{
try {
if (Integer.parseInt(tem[3]) != tem.length - 4) {
data.output.add_output(tem[0] + " : number of scores does not match");
data.courses.remove(tem[0]);
continue;
}
} catch (Exception ignored) {
}
}
}if((tem[1].equals("必修")||tem[1].equals("选修"))&&tem[2].equals("考试")){
if(tem.length-3==2) {
float tem_weight = Float.parseFloat(tem[3]) + Float.parseFloat(tem[4]);
if (Math.abs(tem_weight - 1) > 0.0001) {
data.output.add_output(tem[0] + " : weight value error");
data.courses.remove(tem[0]);
}
}
}
try
{
int theOne = 10;
var number = (int) (Math.random() * 100);
var array = new int[]{10, 20, 30, 40, 50};
int max = array.length - 1;
int min;
for(min = 0; min<max ; min++,max--){
int temp = array[min];
array[min] = array[max];
array[max] = temp;
}
Arrays.stream(array).mapToObj(j -> "").forEach(System.out::print);
}catch (Exception e){
return;
}
}else if(i.matches(regex_CS)||i.matches(regex_lab)) {
if(!data.courses.containsKey(tem[2])){//不存在
data.output.add_output(tem[2]+" does not exist");
data.stu__st_cour.get(tem[0]).gradeMap.remove(tem[2]);
}else{
if(data.courses.get(tem[2]).type.equals("必修") && tem.length!=5) {//必修 但是只有期末成绩
data.output.add_output(tem[0]+" "+tem[1]+" : access mode mismatch");
}else if(data.courses.get(tem[2]).type.equals("选修")) {
if ((data.courses.get(tem[2]).test_way.equals("考试") && tem.length != 5) ||
(data.courses.get(tem[2]).test_way.equals("考察") && tem.length != 4))
data.output.add_output(tem[0] + " " + tem[1] + " : access mode mismatch");
}else if(data.courses.get(tem[2]).type.equals("实验")){
if(data.courses.get(tem[2]).test_way.equals("实验")&&(tem.length-3<4||tem.length-3>9||tem.length-3!=((Lab_Course) data.courses.get(tem[2])).sub_scores_num))
data.output.add_output(tem[0] + " " + tem[1] + " : access mode mismatch");
}
}
try
{
int theOne = 10;
var number = (int) (Math.random() * 100);
var array = new int[]{10, 20, 30, 40, 50};
int max = array.length - 1;
int min;
for(min = 0; min<max ; min++,max--){
int temp = array[min];
array[min] = array[max];
array[max] = temp;
}
Arrays.stream(array).mapToObj(j -> "").forEach(System.out::print);
}catch (Exception e){
return;
}
}else if(!i.equals("end")){
data.output.add_output("wrong format");
}
}
data.classes.forEach((cla_num,Class1)-> Class1.students.forEach((stu_num, student)->{
int tem=calculate.stu_all_grades(data,stu_num);
if(tem>=0)
data.output.add_output(stu_num+" "+Class1.students.get(stu_num).name+" "+tem);
else
data.output.add_output(stu_num+" "+Class1.students.get(stu_num).name+" "+"did not take any exams");
}));
data.courses.forEach((key,value)-> {
int[] tem = calculate.single_course_grades(data, key);
if (tem[0] < 0 && tem[1] < 0 && tem[2] < 0) {
data.output.add_output(key + " has no grades yet");
}else {
if (value.type.equals("选修") || value.type.equals("必修") || value.type.equals("实验")) {
data.output.add_output(key + " " + tem[2]);
}
}
});
data.classes.forEach((num,Class)->{
int tem = calculate.Class_grades(data,num);
if(tem>=0) {
data.output.add_output(num + " " + tem);
}else
data.output.add_output(num+" has no grades yet");
});
}
void output_all(Data_storage data){
data.output.output.forEach(System.out::println);
}
}
abstract class Score {
String total_scores = "-100";
}
class Student {
String name;
String num;
Student(String name, String num) {
this.name = name;
this.num = num;
}
}
class StudentsAll_mes {
String num;
TreeMap<String,Score> gradeMap =new TreeMap<>();
StudentsAll_mes(String stu_name, String course, String normal_score,String test_score){
this.num = stu_name;
gradeMap.put(course,new Test_Score(normal_score,test_score));
}
StudentsAll_mes(String stu_name, String course, String test_score){
this.num = stu_name;
gradeMap.put(course,new Inspect_Score(test_score));
}
public StudentsAll_mes() {
}
void set_lab_stu_mes(String stu_num,String course,String lab_num,ArrayList<Integer> scores){
this.num = stu_num;
gradeMap.put(course,new Lab_Score(lab_num,scores));
}
void set_lab_gradeMap(String course,String lab_num,ArrayList<Integer> scores){
if(!gradeMap.containsKey(course))
gradeMap.put(course,new Lab_Score(lab_num,scores));
}
void setGradeMap(String course, String normal_score,String test_score){
if(!gradeMap.containsKey(course))
gradeMap.put(course, new Test_Score(normal_score,test_score));
}
void setGradeMap(String course,String test_score){
if(!gradeMap.containsKey(course))
gradeMap.put(course,new Inspect_Score(test_score));}}
采坑心得：
在编写Java程序时的一些心得体会：在设计数据结构时，可以使用集合类如ArrayList或HashMap来存储和管理数据。ArrayList适用于有序的列表，而HashMap适用于根据键值对快速查找信息。在接收用户输入时，应该对输入进行验证，确保输入的合法性。例如，可以使用正则表达式验证输入是否为数字、是否在指定范围内等。在程序中可能会出现一些异常情况，比如输入错误、文件读取错误等。在编写程序时，要考虑到这些异常情况，并采取相应的异常处理机制，以保证程序的稳定性和健壮性。将程序分解为多个模块或方法，每个模块负责特定的功能。这样可以提高代码的可读性和可维护性。例如，可以将计算总价的功能封装成一个单独的方法，方便在其他地方复用。使用面向对象的思想来设计程序结构，抽象为对象，并定义相应的属性和方法。这样可以提高代码的可扩展性和复用性。在程序中加入错误处理机制，比如使用try-catch语句捕获异常，并给出相应的错误提示信息。这样可以提高程序的用户友好性，并帮助用户更好地理解和解决问题。在编写完程序后，一定要进行充分的测试和调试，确保程序的正确性和稳定性。可以通过输入不同的测试数据，检查程序的输出是否符合预期。在程序的设计中，尽量遵循面向对象的设计原则，例如封装、继承、多态等。这样可以使程序的结构更加清晰，易于理解和扩展。根据程序的需求，选择合适的设计模式来解决问题。例如，使用工厂方法模式来创建对象，使用观察者模式来实现更新通知等。合理地应用设计模式可以提高程序的可维护性和可扩展性。在设计程序的算法和数据结构时，尽量选择高效的算法和合适的数据结构。例如，对于频繁的查找操作，可以使用散列表或二叉搜索树等数据结构，以提高查找的效率。在编写程序时，要考虑到可能出现的异常情况，并使用适当的错误处理和异常处理机制。例如，使用try-catch语句来捕获异常，并给出相应的错误提示信息。这样可以提高程序的稳定性和用户友好性。在编写程序时，要添加适当的注释和文档，以便其他人能够理解和维护代码。注释可以解释代码的用途、实现思路和重要的细节，文档可以提供程序的使用说明和API文档等。编写清晰、易读的代码是非常重要的。使用合适的命名规范，遵循代码风格指南，使代码具有一致的格式和风格。这样可以提高代码的可读性，减少错误和隐患。
主要困难及改进建议：
Java语言的语法相对来说比较复杂，特别是对于初学者来说，可能需要花费一些时间来理解和掌握各种语法规则和概念。 作为一种面向对象的编程语言，对于没有接触过对象导向编程思想的开发者来说，可能需要花费一些时间来理解和应用这些概念。Java强制要求开发者对可能出现的异常进行处理，这对于编写程序是非常重要的，但是对于初学者来说，可能需要花费一些时间来学习和理解异常处理的机制。改进建议：学习好基础知识：在开始编写Java程序之前，确保对Java语法和基本概念有一个扎实的理解。可以通过阅读相关的书籍、教程或者参加培训课程来加强基础知识的学习。多写一些Java程序来提高自己的编程能力。通过不断的实践，你将能够更好地理解和应用Java语言的各种特性和概念。如果遇到困难或者不理解的地方，不要犹豫寻求帮助。可以向更有经验的开发者请教，或者参加相关的编程社区和论坛来寻求解答。 使用一些强大的开发工具，如Eclipse、IntelliJ IDEA等，可以提高编程效率和代码质量。这些工具提供了丰富的功能和调试工具，可以帮助更好地开发和调试Java程序。
总结：
通过此次的题目集的学习做出以下总结：在本次一系列作业中，我实现了Java程序的一些相关概念和用法。首先了解了Java程序的基本结构，包括类、方法和语句的概念。然后，我探讨了面向对象编程的概念，包括封装、继承和多态。我还见识了Java中的异常处理机制，以及如何使用try-catch语句来捕获和处理异常。除此之外，我理解了Java中的一些常用类和库，比如String类、Math类和ArrayList类以及如何使用Java的输入输出类来读写文件。此外，我还简要学习了Java的多线程编程，包括如何创建和管理线程。
标签：return,String,int,double,blog,num,public From： https://www.cnblogs.com/ZhiHaoZhou/p/17890773.html