（1）前言：
本次博客是对之前发布的7-8次PTA题目集（成绩计算系列）以及期末考试的分析。第7次PTA主要有4道题，两道是容器hashmap的检索和排序。HashMap是Map接口的一个实现类（HashMap实现了Map的接口），它具有Map的特点。Map是用于保存具有映射关系的数据集合，它具有双列存储的特点，即一次必须添加两个元素，即一组键值对==><Key,Value>，其中Key的值不可重复（当Key的值重复的时候，后面插入的对象会将之前插入的具有相同的Key值的对象覆盖掉），Value的值可重复。TreeMap的使用可以按key值进行排序。第三道题是课程成绩统计程序-2，主要是对课程各种成绩的计算，在上一次课程的基础上增加了实验课，因为之前的代码不见了，想用Arrilist和HashMap，报错超过内存，后来发现HahMap这两个的使用会占用很多内存，尽可能少使用。第四题是多态，比较简单。
第8次PTA有5道题，第一题是还是容器排序，在上一次容器排序的基础上增加了一个接口，用来实现自定义排序。第二题是课程成绩统计程序-3，主要是将将成绩类的继承关系改为组合关系，在第二次代码的基础上不用修改很多。第三题是jmu-Java-02基本语法-03-身份证排序，主要是substring（）的使用。第四题是jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack，主要是接口的使用。第五题是jmu-Java-03面向对象基础-05-覆盖，比较简单，覆盖原有的方法。
期末考试的选择题很多不会，理论知识不够，还需要多学，理论的掌握会增加对面向对象的理解。编程题有四题，主要是在魔方的背景实现，第一题是考察类的继承与多态，第二题是考察类之间的关系，第三题是接口的排序，这题卡了有点久，因为main()给出
list.sort(Comparator.naturalOrder());//正向排序不熟悉，以至于找了很久相关知识点，在compare和compartor不确定用哪一个，时间花费了很多。第四题考察类的单一原则实现。这些知识点比较基础，但打代码的包括调代码的能力比较弱，没有写完。
（2）设计与分析：
7-1 容器-HashMap-检索
解题思路：首先创建HashMap，然后再利用.containsKey（）进行检索。里面考察的是hashmap的创建、检索和打印。
通过HashMap存储学生信息，其中键为学号，值为姓名和分数的组合。然后通过循环读取用户输入的学生信息，直到输入"end"结束。接着用户可以输入要查询的学号，程序会检索HashMap中是否存在该学号，如果存在则输出对应的学生信息，如果不存在则输出该学生不存在的提示信息。
//package pta_7;
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
HashMap<String, String> studentMap = new HashMap<>();
String input;
while (!(input = scanner.nextLine()).equals("end")) {
String[] studentInfo = input.split(" ");
String studentId = studentInfo[0];
String name = studentInfo[1];
String score = studentInfo[2];
studentMap.put(studentId, name + " " + score);
}
// 输入要查询的学号
String queryId = scanner.nextLine();
// 检索学生信息
if (studentMap.containsKey(queryId)) {
String studentInfo = studentMap.get(queryId);
System.out.println(queryId+" "+studentInfo);
} else {
System.out.println("The student " + queryId + " does not exist");
}
}
7-2 容器-HashMap-排序
解题思路：创建 TreeMap 对象并根据学号降序排序。hashmap排序有很多种方法，我采用的是TreeMap.
通过HashMap存储学生信息，其中键为学号，值为姓名和分数的组合。然后通过循环读取用户输入的学生信息，直到输入"end"结束。接着将HashMap中的学生信息存入TreeMap，并根据学号降序排序。
//package pta_7;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
HashMap<String, String> studentMap = new HashMap<>();
String input;
while (!(input = scanner.nextLine()).equals("end")) {
String[] studentInfo = input.split(" ");
String studentId = studentInfo[0];
String name = studentInfo[1];
String score = studentInfo[2];
// 将学生信息存入 HashMap
studentMap.put(studentId, name + " " + score);
}
// 创建 TreeMap 对象并根据学号降序排序
TreeMap<String, String> sortedMap = new TreeMap<>(java.util.Collections.reverseOrder());
sortedMap.putAll(studentMap);
// 输出排序后的学生信息
for (Map.Entry<String, String> entry : sortedMap.entrySet()) {
System.out.println(entry.getKey() + " " + entry.getValue());
}
}
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
解题思路：
1. 首先，通过键盘输入获取课程和学生成绩的输入数据。
2. 输入数据以换行符分割成不同的行，然后分别处理每一行的数据。
3. 对于输入的每一行数据，使用正则表达式进行匹配，以确定输入类型。
4. 如果输入是课程信息，则根据输入的课程名称、性质和考核方式创建课程对象，并根据输入信息设置相应的属性。
5. 如果输入是学生成绩信息，则根据输入的学生学号、姓名和课程名称，创建学生对象和成绩对象，并根据输入信息设置相应的属性。如果该成绩信息对应的课程不存在，则输出错误提示信息。
6. 每录入一个学生的成绩，将成绩信息添加到相应学生的成绩列表中。
7. 在学生成绩录入完毕后，遍历学生列表，输出每个学生的学号、姓名和最终成绩。
8. 遍历课程列表，输出每门课程的名称、平时成绩、考试成绩和最终成绩。
9. 遍历班级列表，输出每个班级的班级号和平均成绩。
10. 最后，程序输出是否需要存储所有课程的信息的提示，如果需要，则创建一个存储课程信息的Map，然后通过键盘输入获取课程信息，并存储到Map中。
//package pta_7;
import java.util.*;
//定义课程类
class Course {
String courseName; // 课程名称
String courseProperty; // 课程性质
String assessmentMethod; // 考核方式
List<Integer> scores; // 成绩列表
// int grade;//课程总成绩
//计算单门课程总成绩
// 构造方法
public Course(String courseName, String courseProperty, String assessmentMethod) {
this.courseName = courseName;
this.courseProperty = courseProperty;
this.assessmentMethod = assessmentMethod;
this.scores = new ArrayList<>();
}
// 添加成绩
public void addScore(int score) {
this.scores.add(score);
}
}
//定义学生类
class Student {
String studentId; // 学号
String name; // 姓名
Map<String, Course> courses; // 课程名为主键，课程列表
//计算学生所有课程总成绩的平均分
// 构造方法
public Student(String studentId, String name) {
this.studentId = studentId;
this.name = name;
this.courses = new HashMap<>();
}
//查找课程
public boolean search_couse(String name) {
if (courses.containsKey(name)) return false;
return true;
}
// 添加课程
public void addCourse(String courseName, String courseProperty, String assessmentMethod) {
Course course = new Course(courseName, courseProperty, assessmentMethod);
courses.put(courseName, course);
}
// 添加成绩
public void addScore(String courseName, int score) {
if (courses.containsKey(courseName)) {
courses.get(courseName).addScore(score);
}
}
}
// 计算所有课程总成绩的平均分
/*
public int calculateAverageTotalScore() {
int total = 0;
for (Course course : courses.values()) {
total += course.calculateAverageScore();
}
return total / courses.size();
}
}*/
//成绩统计
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
List<Course> courses = new ArrayList<>();
List<Student> students = new ArrayList<>();
while (scanner.hasNext()) {
String input = scanner.nextLine();
String[] parts = input.split(" ");
int index=0;
if (input.equals("end")) {
break;
}
//课程信息 课程名称、课程性质、考核方式
if (parts.length == 3||parts.length==2) {
String courseName = parts[0];
String courseType = parts[1];
String assessment;
int flag=1;//用来判断输入课程信息，输入的课程性质和课程的考核方式是否匹配
if(parts.length==3) {
assessment = parts[2];
if(courseType.equals("必修")&&assessment.equals("考试")==false) {
System.out.println(courseName+" : course type & access mode mismatch");
flag=0;
}
if(courseType.equals("选修")&&(assessment.equals("考试")||assessment.equals("考察"))){
System.out.println(courseName+" : course type & access mode mismatch");
flag=0;
}
if(courseType.equals("实验")&&assessment.equals("实验")==false) {
System.out.println(courseName+" : course type & access mode mismatch");
flag=0;
}
}
else {
assessment ="考试";
}
if(flag==1)
courses.add(new Course(courseName, courseType, assessment));
}
// 考试/考察成绩 学号、姓名、课程名称、平时成绩（可选）、期末成绩
else if (parts.length <= 5) {
String id = parts[0];
String name = parts[1];
String courseName = parts[2];
int grade1=0,grade2=0;
grade1 = Integer.parseInt(parts[3]);
int flag=1;//输入的成绩数量和课程的考核方式不匹配
boolean found=false;
if(parts.length == 5) {//考试
grade2 = Integer.parseInt(parts[4]);
}
if(grade1>=0&&grade1<=100&&grade2>=0&&grade2<=100) {
for (Course course : courses) {
if (course.courseName.equals(courseName)) //课程存在
{
found=true;
if (course.assessmentMethod.equals("考试") ) //期末成绩为考试
{
if(parts.length!=5) {
System.out.println(id+" "+name+" "+": access mode mismatch");
flag=0;
}
if(flag==1)
{
students.add(new Student(id, name));
students.get(index).addScore(courseName, grade1);
students.get(index).addScore(courseName, grade2);
students.get(index).addCourse(course.courseName, course.courseProperty,course.assessmentMethod);
index++;
}
}
else if(course.assessmentMethod.equals("考察"))//期末成绩为考察
{
if(parts.length!=4) {
System.out.println(id+" "+name+" "+": access mode mismatch");flag=0;
}
if(flag==1)
{
students.add(new Student(id, name));
students.get(index).addScore(courseName, grade1);
students.get(index).addCourse(course.courseName, course.courseProperty,course.assessmentMethod);
index++;
}
}
}
}
if (!found) {//课程不存在
System.out.println(id+" "+name+" "+":"+courseName+" "+"does not exist");
}
}
else {
System.out.println("wrong format");
}
}
// 实验成绩 学号、姓名、课程名称、实验次数、每次成绩
else if (parts.length > 5) {
String id = parts[0];
String name = parts[1];
String courseName = parts[2];
int num = Integer.parseInt(parts[3]);//实验次数
boolean found=false;
int flag=1;
List<Integer>score =new ArrayList<>(); // 成绩列表
int i=4;
while(parts[i]!=null) {
score.add(Integer.parseInt(parts[i])) ;
}
if(score.size()>=4&&score.size()<=9) {//输入的成绩数量和课程的考核方式不匹配
if(score.size()==num) {
for (Course course : courses) {
if (course.courseName.equals(courseName)) {
if (course.assessmentMethod.equals("实验")) {
students.add(new Student(id, name));
for(int j=0;j<score.size();j++) {
students.get(index).addScore(courseName, score.get(j));
}
}
else {
System.out.println(id + " " + name + " : access mode mismatch");
}
}
}
if (!found) {
System.out.println(id + " " + name + " : " + courseName + " does not exist");
}
}
else {
System.out.println("wrong format");
}
}
}
else System.out.println("wrong format");
// 单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按 //课程名称 的字符顺序输出
// 学生课程总成绩平均分按 //学号 由低到高排序输出
// 班级所有课程总成绩平均分按//班级由低到高排序输出
}
}
}
7-4 动物发声模拟器（多态）
解题思路：在抽象类Animal中写好打印方法，在各个类中再进行覆盖。
//package pta_7;
//定义抽象类Animal
abstract class Animal{
public abstract String getAnimalClass();
public abstract void shout();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{
public String getAnimalClass() {
return "猫";
}
public void shout(){
System.out.println("喵喵");
}
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal {
public String getAnimalClass() {
return "狗";
}
public void shout(){
System.out.println( "汪汪");
}
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal {
public String getAnimalClass() {
return "山羊";
}
public void shout(){
System.out.print("咩咩");
}
}
public class Main{
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
Goat goat = new Goat();
speak(cat);
speak(dog);
speak(goat);
}
//定义静态方法speak()
public static void speak(Animal animal) {
System.out.print(animal.getAnimalClass() + "的叫声：");
animal.shout();
}
}
7-1 容器-ArrayList-排序
解题思路：使用Comparable（）接口，自定义comare（）方法进行降序。
- 创建
Student类来表示学生，其中包括ID、姓名、数学成绩和物理成绩的属性，以及比较方法和计算总分的方法。 - 创建
Main类来接收用户输入的学生信息，创建Student对象并将其添加到列表中，然后对列表进行排序，并最终打印排序后的学生信息。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
class Student implements Comparable<Student>{
String id;
String name;
int math;
int phy;
public Student(String id,String name,int math,int phy) {
this.id=id;
this.name=name;
this.math=math;
this.phy=phy;
}
public int compareTo(Student student) {
// 按照数学和物理成绩的总和降序排序
return (student.math + student.phy) - (this.math + this.phy);
// 这种是升序
//return this.getAge() - o.getAge();
// 这种是降序
}
public int total() {
return math+phy;
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
List<Student> array=new ArrayList<>();
String input;
while(!(input=scanner.nextLine()).equals("end")) {
String[] split=input.split(" ");
Student student=new Student(split[0], split[1],Integer.parseInt(split[2]),Integer.parseInt(split[3]));
array.add(student);
}
Collections.sort(array);
for(Student student : array) {
System.out.println(student.id + " " + student.name + " " + student.total());
}
}
}
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 yet
2. 在学生成绩录入部分，对输入的成绩进行了一些合法性校验和错误处理。如果成绩超过100或小于0，则输出错误提示信息。
3. 根据输入行中的长度判断是否存在多个成绩，如果存在，则对多个成绩进行处理，计算平均值。
4. 在输出部分，对学生列表、课程列表和班级列表进行了排序。学生列表按照学号升序排列，课程列表按照课程名称升序排列，班级列表按照班级号升序排列。
5. 修改了InputMatching类中正则表达式的定义，以适应新的输入格式。
6. 删除了一些没有使用的变量和代码块。
总体来说，该版本的代码在功能和逻辑上与上一个版本相似，但进行了一些优化和调整，使得代码更加清晰和简洁。同时，对输入的成绩进行了合法性校验和错误处理，对输出结果进行了排序，提高了程序的稳定性和可读性。
解题思路：
import java.util.*;
import java.text.Collator;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Course[] course = new Course[100];
Student[] student = new Student[100];
Cls[] cls = new Cls[100];
int fsfu = 0; //课程数量
int afhas = 0; //学生数量
int classCount = 0; //班级数量
/*获取输入*/
StringBuilder sb = new StringBuilder();
HashSet<String> set = new HashSet<>();
while (sc.hasNextLine()) {
String s = sc.nextLine();
if (s.equals("end")) {
break;
}
if (set.add(s)) { // 添加成功则说明是第一次出现的行，才将其加入 StringBuilder 中
sb.append(s).append("\n");
}
}
String str = sb.toString();
String[] lines = str.split("\n");
for(String line : lines)
{
String[] words = line.split(" ");
boolean repeat = false;
if(InputMatching.matchingInput(line)==1)
{
for(int i=0;i<fsfu;i++){
if(words[0].equals(course[i].getName())){
repeat = true;
break;
}
}if(repeat) continue;
course[fsfu] = new Course();
course[fsfu].setName(words[0]);
/*选修与必修*/
switch (words[1]) {
case "必修":
course[fsfu].required = true;
break;
case "选修":
course[fsfu].required = false;
break;
case "实验":
course[classCount].pre = true;
break;
}
/*考试与考察与实验*/
boolean pra = false;
if(words[1].equals("实验")){
pra = true;
if(words[2].equals("实验")){
course[fsfu].pre = true;
}else {
course[fsfu].format = false;
System.out.println(words[0]+" : course type & access mode mismatch");
course[fsfu].setName(null);
}
}
if(course[fsfu].required&&!pra) {
course[fsfu].test = true;
if(words[2].equals("考察")||words[2].equals("实验")){
course[fsfu].format = false;
System.out.println(words[0]+" : course type & access mode mismatch");
course[fsfu].setName(null);
}
}else if(!pra){
switch (words[2]) {
case "考试":
course[fsfu].test = true;
break;
case "考察":
course[fsfu].test = false;
break;
case "实验":
course[fsfu].format = false;
System.out.println(words[0] + " : course type & access mode mismatch");
course[fsfu].setName(null);
break;
}
}
fsfu++;
}
else if(InputMatching.matchingInput(line)==2||words.length>=5)
{
boolean mistake = false;
if(Integer.parseInt(words[3])>100){
System.out.println("wrong format");
continue;
}
if(words.length>5){
if(Integer.parseInt(words[3])<4||Integer.parseInt(words[3])>9){
System.out.println("wrong format");
continue;
}try {
for (int i = 0; i < Integer.parseInt(words[3]); i++) {
if (Integer.parseInt(words[i + 4]) > 100 || Integer.parseInt(words[i + 4]) < 0) {
mistake = true;
}
}
}catch (ArrayIndexOutOfBoundsException ignored){
}
if(mistake) {
System.out.println("wrong format");
continue;
}
}
int dgjhds = 0;
int gdghjds = 0;
int studentIndex = 0;
boolean exist = false;
boolean createStudent = true;
boolean createClass = true;
String classID = words[0].substring(0,6);
/*获取课程下标*/
for(int i=0;i<fsfu;i++){
if(words[2].equals(course[i].getName())){
dgjhds = i;
exist = true;
break;
}
}
/*不存在课程*/
if(!exist){
System.out.println(words[2]+" does not exist");
}
/*已存在该班*/
for(int i=0;i<classCount;i++){
if(classID.equals(cls[i].getID())){
createClass = false;
gdghjds = i;
break;
}
}
if(createClass){
gdghjds = classCount;
cls[classCount] = new Cls();
cls[classCount].setID(classID);
classCount++;
}
/*已存在该学生*/
for(int i=0;i<afhas;i++){
if(words[0].equals(student[i].getID())){
createStudent = false;
studentIndex = i;
break;
}
}
if(createStudent) {
student[afhas] = new Student();
student[afhas].setID(words[0]);
student[afhas].setName(words[1]);
if(words.length==4){
if(course[dgjhds].pre){
System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
continue;
}
if(course[dgjhds].test){
if(exist)
System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
student[afhas].format = false;
}else{
student[afhas].setScore(Integer.parseInt(words[3]));
course[dgjhds].setTestScore(Integer.parseInt(words[3]));
course[dgjhds].setScore(Integer.parseInt(words[3]));
cls[gdghjds].setScore(Integer.parseInt(words[3]));
}
}else if(words.length==5){
if(course[dgjhds].pre){
System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
continue;
}
if(!course[dgjhds].test){
if(exist)
System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
student[afhas].format = false;
}else{
student[afhas].setScore(Integer.parseInt(words[3])*0.3+Integer.parseInt(words[4])*0.7);
cls[gdghjds].setScore(Integer.parseInt(words[3])*0.3+Integer.parseInt(words[4])*0.7);
course[dgjhds].setTestScore(Integer.parseInt(words[4]));
course[dgjhds].setTimeScore(Integer.parseInt(words[3]));
course[dgjhds].setScore(Integer.parseInt(words[3])*0.3+Integer.parseInt(words[4])*0.7);
}
}else if(words.length<8){
System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
}else {
double theWhole = 0;
double theAverage;
int gdsfdshgd = Integer.parseInt(words[3]);
if(words.length-4 != gdsfdshgd){
System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
continue;
}
for(int i = 0;i<gdsfdshgd;i++){
theWhole += Integer.parseInt(words[i+4]);
}
theAverage = theWhole / gdsfdshgd;
student[afhas].setScore(theAverage);
course[dgjhds].setScore(theAverage);
cls[gdghjds].setScore(theAverage);
}
afhas++;
}else {
if(words.length==4){
if(course[dgjhds].test){
if(exist)
System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
student[studentIndex].format = false;
}else{
student[studentIndex].setScore(Integer.parseInt(words[3]));
course[dgjhds].setTestScore(Integer.parseInt(words[3]));
course[dgjhds].setScore(Integer.parseInt(words[3]));
cls[gdghjds].setScore(Integer.parseInt(words[3]));
}
}else if(words.length==5){
if(!course[dgjhds].test){
if(exist)
System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
student[studentIndex].format = false;
}else{
student[studentIndex].setScore(Integer.parseInt(words[3])*0.3+Integer.parseInt(words[4])*0.7);
cls[gdghjds].setScore(Integer.parseInt(words[3])*0.3+Integer.parseInt(words[4])*0.7);
course[dgjhds].setTestScore(Integer.parseInt(words[4]));
course[dgjhds].setTimeScore(Integer.parseInt(words[3]));
course[dgjhds].setScore(Integer.parseInt(words[3])*0.3+Integer.parseInt(words[4])*0.7);
}
}else if(words.length<8){
System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
}
else {
double theWhole = 0;
double theAverage;
int gdsfdshgd = Integer.parseInt(words[3]);
if(words.length-4 != gdsfdshgd){
System.out.println(words[0]+" "+words[1]+" : access mode mismatch");
continue;
}
for(int i = 0;i<gdsfdshgd;i++){
theWhole += Integer.parseInt(words[i+4]);
}
theAverage = theWhole / gdsfdshgd;
student[afhas].setScore(theAverage);
course[dgjhds].setScore(theAverage);
cls[gdghjds].setScore(theAverage);
}
}
}else System.out.println("wrong format");
}
List<Student> studentList = new ArrayList<>(Arrays.asList(student).subList(0, afhas));
List<Cls> clsList = new ArrayList<>(Arrays.asList(cls).subList(0, classCount));
List<Course> courseList = new ArrayList<>(Arrays.asList(course).subList(0, fsfu));
Collections.sort(studentList);
Collections.sort(clsList);
courseList.sort(new CourseComparator());
for(Student students : studentList){
if(students.getScore()==0){
System.out.println(students.getID()+" "+students.getName()+ " did not take any exams");
}
else{
System.out.println(students.getID()+" "+students.getName()+" "+ students.lastScore());
}
}
for(Course course1 : courseList){
if(course1.getScore()==0&&course1.format){
System.out.println(course1.getName()+" has no grades yet");
}else{
if(course1.pre&&course1.format){
System.out.println(course1.getName()+" "+ (int)course1.getScore()/course1.getScoreCount());
}
else if(course1.test&&course1.format){
System.out.println(course1.getName()+" "+(int)course1.getTimeScore()/course1.getScoreCount()+" "+
(int)course1.getTestScore()/course1.getScoreCount()+" "+(int)course1.getScore()/course1.getScoreCount());
}else if(course1.format){
System.out.println(course1.getName()+" "+
(int)course1.getTestScore()/course1.getScoreCount()+" "+(int)course1.getScore()/course1.getScoreCount());
}
}
}
for(Cls cls1 : clsList){
if(cls1.getScore()==0){
System.out.println(cls1.getID()+" has no grades yet");
}else{
System.out.println(cls1.getID()+" "+(int)cls1.getScore()/cls1.getScoreCount());
}
}
boolean useful = false;
if(useful){
HashMap<String,String> map = new HashMap<>();
String str2;
while(true) {
str = sc.nextLine();
if(str.equals("end")){
break;
}
String []arr = str.split(" ");
String num = arr[0];
String name = arr[1];
String grade = arr[2];
if(map.containsKey(num)){
System.out.println("学号重复，请重新输入");
} else {
map.put(num,name+" "+grade);
}
}
String s = sc.nextLine();
if(map.containsKey(s)){
String []arr = map.get(s).split(" ");
System.out.println(s+" "+arr[0]+" "+arr[1]);
} else {
System.out.println("The student "+s+" does not exist");
}
}
Map<Integer, String[]> map = new HashMap<>(); //使用HashMap存储学生信息，键为学号，值为字符串数组，依次存储学号、姓名、成绩
while (true) {
String[] input = sc.nextLine().split(" ");
if (input[0].equals("end")) {
break;
}
int id = Integer.parseInt(input[0]);
String[] info = {input[1], input[2]}; //将姓名和成绩存储在一个字符串数组中
map.put(id, info);
}
List<Integer> ids = new ArrayList<>(map.keySet());
Collections.sort(ids, Collections.reverseOrder()); //按学号从大到小排序
for (int id : ids) {
String[] info = map.get(id);
System.out.println(id + " " + info[0] + " " + info[1]); //依次输出学号、姓名、成绩
}
}
}
class CourseComparator implements Comparator<Course> {
@Override
public int compare(Course c1, Course c2) {
Collator collator = Collator.getInstance(Locale.CHINA);
return collator.compare(c1.getName(), c2.getName());
}
}
class Course implements Comparable<Course>{
private String name;
private double timeScore=0;
private double testScore=0;
private double score=0;
private int scoreCount=0;
public boolean test;
public boolean required;
public boolean format = true;
public boolean pre;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getTimeScore() {
return timeScore;
}
public void setTimeScore(double timeScore) {
this.timeScore += timeScore;
}
public double getTestScore() {
return testScore;
}
public void setTestScore(double testScore) {
this.testScore += testScore;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score += score;
this.scoreCount++;
}
public int getScoreCount() {
return scoreCount;
}
// 实现Comparable接口中的compareTo方法，按照课程名称字符顺序排列
@Override
public int compareTo(Course other) {
return this.name.compareTo(other.getName());
}
}
class Student implements Comparable<Student>{
private String ID;
private String name;
private double score;
private int scoreCount=0;
public boolean format = true;
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID = ID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score += score;
this.scoreCount++;
}
public int lastScore(){
return (int)score/scoreCount;
}
// 定义比较规则：按照id升序排列
@Override
public int compareTo(Student o) {
return Integer.compare(Integer.parseInt(this.ID), Integer.parseInt(o.ID));
}
}
class Cls implements Comparable<Cls>{
private String ID;
private double score;
private int scoreCount=0;
public void setID(String ID){
this.ID = ID;
}
public String getID(){
return ID;
}
public void setScore(double score) {
this.score += score;
this.scoreCount++;
}
public double getScore(){
return score;
}
public int getScoreCount() {
return scoreCount;
}
// 定义比较规则：按照id升序排列
@Override
public int compareTo(Cls o) {
return Integer.compare(Integer.parseInt(this.ID), Integer.parseInt(o.ID));
}
}
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 = "(考试|考察|实验)";
static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching;
/*courseInput用于定义课程信息模式（正则表达式）*/
static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
scoreMatching + "(scoreMatching)?";
static String scoreInput2 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
scoreMatching + "(scoreMatching)?" + " " + scoreMatching + "(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)||s.matches(scoreInput2);
}
}
7-3 jmu-Java-02基本语法-03-身份证排序
解题思路：首先用substring()提取所需要的字符串，然后分别用Arrays.sort();排序。
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
String m;int i,n;
Scanner scanner=new Scanner(System.in);
m=scanner.nextLine();n=Integer.parseInt(m);
String[] a=new String[n],b=new String[n];
for(i=0;i<n;i++)
{
a[i]=scanner.nextLine();//System.out.println(i);
}
String choice=scanner.nextLine();//System.out.println(a[1]);
while(choice.equals("sort1")||choice.equals("sort2")) {
if(choice.equals("sort1")) {
for(i=0;i<n;i++) {
b[i]=a[i].substring(6, 10)+"-"+a[i].substring(10, 12)+"-"+a[i].substring(12, 14);
}
Arrays.sort(b);
for(i=0;i<n;i++)
System.out.println(b[i].toString());
}
else {
for(i=0;i<n;i++)
b[i]=a[i].substring(6,14);
Arrays.sort(b);
for(i=0;i<n;i++)
for(int j=0;j<n;j++)
if(a[j].contains(b[i]))
System.out.println(a[j]);
}
choice=scanner.nextLine();
}
if(!(choice.equals("sort1")||choice.equals("sort2"))) System.out.println("exit");
}
}
7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
解题思路：首先定义了一个interface IntegerStack接口，然后在类ArrayIntegerStack中实现了该接口的类。
IntegerStack接口。该接口定义了整数栈的基本操作，包括入栈(push)、出栈(pop)、获取栈顶元素(peek)、判断栈是否为空(empty)以及获取栈中元素个数(size)的方法。
ArrayIntegerStack类，它实现了IntegerStack接口。该类使用数组a[]来存储整数栈的元素，并使用top来表示栈顶指针。在构造函数中，它接收一个整数作为参数，用于初始化数组a[]的大小。
在push方法中，如果要入栈的元素为null，则直接返回null；如果栈已满，则返回null；否则将元素入栈，并将top指针后移。
在pop方法中，如果栈为空，则返回null；否则将top指针前移，并返回栈顶元素。
在peek方法中，如果栈为空，则返回null；否则返回栈顶元素。
在empty方法中，如果栈为空则返回true，否则返回false。
在size方法中，返回栈中元素的个数。
//import com.sun.org.apache.regexp.internal.RE;
import java.util.Arrays;
import java.util.Scanner;
interface IntegerStack{
public Integer push(Integer item);
//如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。
public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
public Integer peek(); //获得栈顶元素，如果为空，则返回null.
public boolean empty(); //如果为空返回true
public int size(); //返回栈中元素个数
}
class ArrayIntegerStack implements IntegerStack{
public Integer a[];
public Integer top=0;
public ArrayIntegerStack(int num) {
a=new Integer[num];
}
public Integer push(Integer item) {
if (item==null){
return null;
}
if (top==a.length){
return null;
}
a[top]=item;
top++;
return item;
}
public Integer pop() {
if (top==0){
return null;
}
top--;
return a[top];
}
public Integer peek() {
if (top==0){
return null;
}
return a[top-1];
}
@Override
public boolean empty() {
if (top==0){
return true;
}
return false;
}
@Override
public int size() {
return top;
}
}
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
ArrayIntegerStack array = new ArrayIntegerStack(sc.nextInt());
int num=sc.nextInt();
for(int i=0;i<num;i++){
System.out.println(array.push(sc.nextInt()));
}
System.out.println(array.peek()+","+array.empty()+","+array.size());
String arr=array.toString();
System.out.println(Arrays.toString(array.a));
int time=sc.nextInt();
for (int i=0;i<time;i++){
System.out.println(array.pop());
}
System.out.println(array.peek()+","+array.empty()+","+array.size());
System.out.println(Arrays.toString(array.a));
}
}
7-5 jmu-Java-03面向对象基础-05-覆盖
解题思路：考察的是类的有参构造和无参构造。 PersonOverride类，它包含了三个私有属性：name、age和gender，以及对应的构造方法、getter和setter方法，以及toString方法和equals方法。构造方法包括无参构造方法和带参数的构造方法，用于初始化对象的属性。toString方法用于将对象的属性以字符串的形式返回，而equals方法用于比较两个PersonOverride对象是否相等。
//package pta_8;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
class PersonOverride{
private String name;
private int age;
private boolean gender;
public PersonOverride(){
this("default",1,true);
}
public PersonOverride(String name,int age,boolean gender){
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean getGender() {
return gender;
}
public void setGender(boolean gender) {
this.gender = gender;
}
public String toString(){
return this.name+"-"+this.age+"-"+this.gender;
}
public boolean equals(PersonOverride a) {
if(!(this.name.equals(a.getName()))) return false;
if(!(this.age==a.getAge())) return false;
if(!(this.gender==a.getGender())) return false;
return true;
}
}
public class Main{
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
2.1 输入n1，使用无参构造方法创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。
*/
int n1,n2,i;
Scanner scanner=new Scanner(System.in);
n1=scanner.nextInt();
n2=scanner.nextInt();
ArrayList<PersonOverride> person1 = new ArrayList<>();
ArrayList<PersonOverride> person2 = new ArrayList<>();
for ( i = 0; i < n1; i++) {
person1.add(new PersonOverride());
}
for ( i = 0; i < n2; i++) {
String name = scanner.next();
int age = scanner.nextInt();
boolean gender = "true".equals(scanner.next());
PersonOverride temp = new PersonOverride(name,age,gender);
//如果对象在集合不存在就添加
if(Exists(person2,temp)){
person2.add(temp);
}
}
for (PersonOverride override : person1) {
System.out.println(override.toString());
}
for (PersonOverride personOverride : person2) {
System.out.println(personOverride.toString());
}
System.out.println(person2.size());
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
}
public static boolean Exists(ArrayList<PersonOverride> person2, PersonOverride temp) {
for (Personverride Override personO: person2) {
if(personOverride.equals(temp)){
return false;
}
}
return true;
}
}
7-3 魔方排序问题
解题思路：在RubikCube类要实现Comparable接口。list.sort(Comparator.naturalOrder());//正向排序这个排序因为不熟悉，不知道如何构造
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
class Solid {
private double r = 0;
public Solid(double r) {
this.r = r;
}
public double getsolid() {
return r;
}
public void setsolid(double r) {
this.r = r;
}
public double getarea() {
return 0;
}
public double getvolume() {
return 0;
}
}
class Cube extends Solid {
public Cube(double r) {
super(r);
}
public double getarea() {
return 6 * getsolid() * getsolid();
}
public double getvolume() {
return getsolid() * getsolid() * getsolid();
}
}
class RegularPyramid extends Solid {
public RegularPyramid(double r) {
super(r);
}
public double getarea() {
return getsolid() * getsolid() * Math.sqrt(3);
}
public double getvolume() {
return Math.sqrt(2) * getsolid() * getsolid() * getsolid() / 12;
}
}
abstract class RubikCube implements Comparable<RubikCube>{
private String color;
private int layer;
private Solid solid;
public RubikCube(String color, int layer, Solid solid) {
this.color = color;
this.layer = layer;
this.solid = solid;
}
public String getcolor() {
return color;
}
public void setcolor(String color) {
this.color = color;
}
public int getlayer() {
return layer;
}
public void setlayer(int layer) {
this.layer = layer;
}
public double getarea() {
return solid.getarea();
}
public double getvolume() {
return solid.getvolume();
}
public Solid getSolid() {
return solid;
}
public void setSolid(Solid solid) {
this.solid = solid;
}
public int compareTo(RubikCube o) {
// 按照数学和物理成绩的总和降序排序
//return (student.math + student.phy) - (this.math + this.phy);
// 这种是升序
return (int) (this.getvolume() - o.getvolume());
// 这种是降序
}
}
class SquareCube extends RubikCube {
public SquareCube(String color, int layer, Cube cube) {
super(color, layer, cube);
}
@Override
public double getarea() {
return getSolid().getarea();
}
@Override
public double getvolume() {
return getSolid().getvolume();
}
}
class RegularPyramidCube extends RubikCube {
public RegularPyramidCube(String color, int layer, RegularPyramid pyramid) {
super(color, layer, pyramid);
}
@Override
public double getarea() {
return getSolid().getarea();
}
@Override
public double getvolume() {
return getSolid().getvolume();
}
}
public class Main_2 {
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("");
}
}
}
（3）改进建议：
在构造Main函数的时，遇到了以下问题：
1. 输入合法性验证：代码中对输入的合法性进行了一些验证和错误处理。然而，这部分代码仍然比较冗长，可读性较差，很多重复的判断逻辑。这可能会导致代码的维护和扩展困难。
2. 代码重复：代码中存在一些重复的判断逻辑和重复的代码块，使得代码的冗余度较高，可读性较差，也增加了代码维护的难度。
改进的建议：
1. 提取公共方法：将输入合法性验证和错误处理的逻辑提取为独立的方法，以提高代码的可读性和可维护性。可以考虑设计一个输入处理类，将输入的合法性判断、错误处理和信息存储等功能封装在该类中，使得代码更加模块化和易于扩展。
2. 减少重复代码：通过提取公共方法、使用循环和条件语句等方式，减少代码中的重复逻辑和重复代码的存在。可以通过抽象出公共的判断和处理逻辑，将其封装成独立的方法或工具类，方便复用和维护。
3. 引入异常处理：对于输入合法性验证和错误处理，可以引入异常处理机制，使用自定义异常类来表示不合法的输入和错误情况，从而增加代码的可读性和可维护性。
4. 简化数据结构：通过优化数据结构的设计，减少不必要的属性和方法，可以提高代码的简洁性和可读性。比如，可以考虑使用Map来存储学生和课程信息，以简化代码的逻辑。
综上所述，改进的主要方向是简化代码逻辑、减少重复代码和提高代码的可读性和可维护性。通过引入更好的设计模式和编码规范，可以使代码更加简洁和易于理解。
（4）总结：
这次pta重点是hashmap和Arrlist和类之间的关系，HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。HashMap 的实现不是同步的，这意味着它不线程的。它的 key、value 都可以为 null，此外，HashMap 中的映射不是有序的。ArrayList 是 java 集合框架中比较常用的数据结构了。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。
标签：return,String,int,博客,课程,成绩,public,第三次 From： https://www.cnblogs.com/hiuhv/p/17892019.html