小结blog3
一.前言
这篇博客主要是PTA7，8次题目集和期末考试的一次习题总结,在熟悉了面向对象三大特征继承，封装，多态前提下对接口的使用，排序方法的重写，Object类中String方法的重写，hashmap.treemap等知识点的深刻了解.加深了我个人对java知识体系的了解，以及在题目中对设计模式的体会。
pta7题目集
7-1 容器-HashMap-检索
7-2 容器-HashMap-排序
7-3 课程成绩统计程序-2
7-4 动物发声模拟器（多态）
pta8题目集
7-1 容器-ArrayList-排序
7-2 课程成绩统计程序-3
7-3 jmu-Java-02基本语法-03-身份证排序
7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
7-5 jmu-Java-03面向对象基础-05-覆盖
期末题集
7-1 立体图形问题
7-2 魔方问题
7-3 魔方排序问题
7-4 销售步枪问题（附加题）
二.设计与分析
7-1 容器-HashMap-检索
作者 蔡轲
单位 南昌航空大学
输入多个学生的成绩信息，包括：学号、姓名、成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
使用HashMap存储学生信息，并实现根据学号的检索功能
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩
以“end”为输入结束标志
end之后输入某个学号，执行程序输出该生的详细信息
输出格式:
输出查询到的学生信息格式：学号+英文空格+姓名+英文空格+成绩
如果没有查询到，则输出："The student "+查询的学号+" does not exist"
输入样例1:
在这里给出一组输入。例如：
20201107 张少军 83
20201116 李四 78
20201118 郑觉先 80
end
20201116
输出样例1:
在这里给出相应的输出。例如：
20201116 李四 78
输入样例2:
在这里给出一组输入。例如：
20201107 张少军 83
20201116 李四 78
20201118 郑觉先 80
end
20202316
输出样例2:
在这里给出相应的输出。例如：
The student 20202316 does not existimport java.util.*;
class Main {
public static void main(String[] args) {
Scanner indata =new Scanner(System.in);
HashMap<String,String> sMap = new HashMap<>();
while (true){
String a =indata.nextLine();
if(a.equals("end")){
break;
}
String[]b=a.split(" ");
sMap.put(b[0],b[1]+" "+b[2]);
}
String conform= indata.nextLine();
if(sMap.containsKey(conform)){
System.out.println(conform+" "+sMap.get(conform));
}
else{
System.out.println("The student " + conform + " does not exist");
}
}
}
总结：该题主要是熟悉hashmap的使用
7-2 容器-HashMap-排序
作者 蔡轲
单位 南昌航空大学
输入多个学生的成绩信息，包括：学号、姓名、成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
要求：使用HashMap存储学生信息。
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩
以“end”为输入结束标志
输出格式:
按学号从大到小的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+成绩
输入样例:
在这里给出一组输入。例如：
20201124 张少军 83
20201136 李四 78
20201118 郑觉先 80
end
输出样例:
在这里给出相应的输出。例如：
20201136 李四 78
20201124 张少军 83
20201118 郑觉先 80
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 indata =new Scanner(System.in);
HashMap<String,String> sMap = new HashMap<>();
while (true){
String a =indata.nextLine();
if(a.equals("end")){
break;
}
String[]b=a.split(" ");
sMap.put(b[0],b[1]+" "+b[2]);
}
TreeMap<String, String> tMap = new TreeMap<>(sMap);
for (Map.Entry<String, String> entry : tMap.descendingMap().entrySet())
{
System.out.println(entry.getKey() + " " + entry.getValue());
}
}
}
总结：可以使用treemap进行排序，
TreeMap<String, String> tMap = new TreeMap<>(sMap);
7-3 课程成绩统计程序-2
作者 蔡轲
单位 南昌航空大学
课程成绩统计程序-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）成绩平均分只取整数部分，小数部分丢弃
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
static ArrayList<Student> studentList = new ArrayList<>();
static ArrayList<Course> courseList = new ArrayList<>();
static ArrayList<Class> classList = new ArrayList<>();
static ArrayList<ChooseCourse> chooseCourseList = new ArrayList<>();
public static void main(String[] args) {
Scanner indata = new Scanner(System.in);
String sNum = "[0-9]{8}";
String sName = "\\S{1,10}";
String sc = "([1-9]?[0-9]|100)";
String tc = "([4-9])";
String CN = "\\S{1,10}";
String XB = "(选修|必修|实验)";
String SC = "(考试|考察|实验)";
String In1 = CN + " " + XB + " " + SC;
String In2 = sNum + " " + sName + " " + CN + " " +
sc;
String In3 = sNum + " " + sName + " " + CN + " " +
sc + " " + sc;
String In4 = sNum+ " "+sName+ " "+CN+" "+tc+"(\\s([1-9]?[0-9]|100))*";
while (true) {
String a = indata.nextLine();
if (a.matches("end"))
{
break;
}
if (a.matches(In1)) {
String[] b = a.split(" ");
String courseName = b[0];//课程名
String type = b[1];//课程类型
String testType = b[2];//课程考试类型
Course course = new Course(courseName, type, testType);
if(b[1].matches("必修")&&b[2].matches("考试")){
if (conformCourse(courseName) == null) {
courseList.add(course);
}
}
else if(b[1].matches("选修")&&b[2].matches("考试")){
if (conformCourse(courseName) == null) {
courseList.add(course);
}
}
else if(b[1].matches("选修")&&b[2].matches("考察")){
if (conformCourse(courseName) == null) {
courseList.add(course);
}
}
else if(b[1].matches("实验")&&b[2].matches("实验")){
if (conformCourse(courseName) == null) {
courseList.add(course);
}
}
else{
System.out.println(course.getCourseName()+" : course type & access mode mismatch");
}
}
if (a.matches(In2)) {
String[] b = a.split(" ");
String stuId = b[0];//学生学号
String classID = b[0].substring(0, 6);
String name = b[1];//学生姓名
String courseName = b[2];//课程名字
if (conformClass(classID) == null) {
Class class1 = new Class(classID);
classList.add(class1);
}
Student stu = new Student(classID, stuId, name);
if (!conformStudent(stuId)) {
studentList.add(stu);
}
if (conformCourse(courseName) == null) {
System.out.println(courseName + " " + "does not exist");
}
if (conformCourse(courseName) != null) {
Course course = conformCourse(courseName);
if (course.testType.equals("考察")) {
int finalGrade = Integer.parseInt(b[3]);
AssessGrade assessGrade = new AssessGrade(finalGrade);
ChooseCourse chooseCourse = new ChooseCourse(course, stu, assessGrade);
if (!conformChooseCourse(name, courseName))
chooseCourseList.add(chooseCourse);
} else {
System.out.println(stuId + " " + name + " " + ": access mode mismatch");
}
}
}
if (a.matches(In3)) {
String[] b = a.split(" ");
String stuId = b[0];//学生学号
String classID = b[0].substring(0, 6);
String name = b[1];//学生姓名
String courseName = b[2];//课程名字
if (conformClass(classID) == null) {
Class class1 = new Class(classID);
classList.add(class1);
}
Student stu = new Student(classID, stuId, name);
if (!conformStudent(stuId)) {
studentList.add(stu);
}
if (conformCourse(courseName) == null) {
System.out.println(courseName + " " + "does not exist");
}
if (conformCourse(courseName) != null) {
Course course = conformCourse(courseName);
if (course.testType.equals("考试")) {
int usualGrade = Integer.parseInt(b[3]);
int finalGrade = Integer.parseInt(b[4]);
ExamGrade examGrade = new ExamGrade(usualGrade, finalGrade);
ChooseCourse chooseCourse = new ChooseCourse(course, stu, examGrade);
if (!conformChooseCourse(name, courseName))
chooseCourseList.add(chooseCourse);
} else {
System.out.println(stuId + " " + name + " " + ": access mode mismatch");
}
}
}
if (a.matches(In4)) {
String[] b = a.split(" ");
String stuId = b[0];
String classID = b[0].substring(0, 6);
String name = b[1];
String courseName = b[2];
String n = b[3];
int num = Integer.parseInt(b[3]);
if (conformClass(classID) == null) {
Class class1 = new Class(classID);
classList.add(class1);
}
Student stu = new Student(classID, stuId, name);
if (!conformStudent(stuId)) {
studentList.add(stu);
}
if (conformCourse(courseName) == null) {
System.out.println(courseName + " " + "does not exist");
}
if (conformCourse(courseName) != null) {
Course course = conformCourse(courseName);
if (b.length == (num+4)) {
TestGrade testGrade = new TestGrade();
for(int j=0;j<num;j++){
testGrade.add = testGrade.add + Integer.parseInt(b[4+j]) ;
}
testGrade.count = num;
ChooseCourse chooseCourse = new ChooseCourse(course, stu, testGrade);
if (!conformChooseCourse(name, courseName))
chooseCourseList.add(chooseCourse);
}
else {
System.out.println(b[0] + " " + b[1] + " : access mode mismatch");
}
}
}
if(!a.matches(In1)&&!a.matches(In2)&&!a.matches(In3)&&!a.matches(In4)){
System.out.println("wrong format");
}
}
printStudents();
printCourses();
printClasses();
}
public static Course conformCourse(String name) {
for (Course course : courseList) {
if (course.getCourseName().equals(name))
return course;
}
return null;
}
public static Class conformClass(String classId) {
for (Class cls : classList) {
if (cls.getClassId().equals(classId))
return cls;
}
return null;
}
public static boolean conformStudent(String id) {
for (Student student : studentList) {
if (student.getId().equals(id))
return true;
}
return false;
}
public static boolean conformChooseCourse(String stuName, String courseName) {
for (ChooseCourse cs : chooseCourseList) {
if (cs.student.getName().equals(stuName) && cs.course.getCourseName().equals(courseName))
return true;
}
return false;
}
public static void printStudents(){
Collections.sort(studentList);
for(int i=0;i<studentList.size();i++){
Student stu=studentList.get(i);
ArrayList<ChooseCourse> stuCourseSelects=getStudentSelects(stu.getId());
if(stuCourseSelects.size()!=0) {
System.out.println(stu.getId()+" "+stu.getName()+" "+getAvgTotalScore(stuCourseSelects));
}
else if(stuCourseSelects.size()==0){
System.out.println(stu.getId()+" "+stu.getName()+" "+"did not take any exams");
}
}
}
public static ArrayList<ChooseCourse> getStudentSelects(String id) {
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse cos : chooseCourseList) {
if (cos.student.getId().equals(id))
choose.add(cos);
}
return choose;
}
public static int getAvgTotalScore(ArrayList<ChooseCourse> cs){
int average=0;
int sum=0;
for(ChooseCourse c:cs){
sum+=c.grade.getTotalGrade();
}
average=sum/cs.size();
return average;
}
public static void printCourses(){
Collections.sort(courseList);
for(int i=0;i<courseList.size();i++){
Course course=courseList.get(i);
ArrayList<ChooseCourse> stuCourseSelects=getCourseSelects(course.getCourseName());
if(stuCourseSelects.size()!=0){
if(course.testType.equals("考试"))
System.out.println(course.getCourseName()+" "+getAvgUsualScore(stuCourseSelects)+" "+getAvgFinalScore(stuCourseSelects)+" "+getAvgTotalScore(stuCourseSelects));
if(course.testType.equals("考察"))
System.out.println(course.getCourseName()+" "+getAvgFinalScore(stuCourseSelects)+" "+getAvgTotalScore(stuCourseSelects));
if(course.testType.equals("实验"))
System.out.println(course.getCourseName()+" "+getAvgTotalScore(stuCourseSelects));
}
else if(stuCourseSelects.size()==0){
System.out.println(course.courseName+" "+"has no grades yet");
}
}
}
public static ArrayList<ChooseCourse> getCourseSelects(String courseName) {
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse cos : chooseCourseList) {
if (cos.course.getCourseName().equals(courseName))
choose.add(cos);
}
return choose;
}
public static int getAvgUsualScore(ArrayList<ChooseCourse> cs){
int average=0;
int sum=0;
for(ChooseCourse c:cs){
if(c.course.getTestType().equals("考试")){
sum+=c.grade.usualGrade;
}
}
average=sum/cs.size();
return average;
}
public static int getAvgFinalScore(ArrayList<ChooseCourse> cs){
int average=0;
int sum=0;
for(ChooseCourse c:cs){
sum+=c.grade.finalGrade;
}
average=sum/cs.size();
return average;
}
public static void printClasses() {
Collections.sort(classList);
for (int i = 0; i < classList.size(); i++) {
Class cls = classList.get(i);
ArrayList<ChooseCourse> stuCourseSelects = getClassSelects(cls.getClassId());
if (stuCourseSelects.size() != 0) {
System.out.println(cls.getClassId() + " " + getAvgTotalScore(stuCourseSelects));
} else if (stuCourseSelects.size() == 0) {
System.out.println(cls.getClassId() + " " + "has no grades yet");
}
}
}
public static ArrayList<ChooseCourse> getClassSelects(String clsId){
ArrayList<ChooseCourse> choose =new ArrayList<>();
for(ChooseCourse cos:chooseCourseList) {
if (cos.student.getclassId().equals(clsId))
choose.add(cos);
}
return choose;
}
}
class ChooseCourse {
Course course;
Student student;
Grade grade;
public ChooseCourse(Course course, Student student, Grade grade) {
this.course = course;
this.student = student;
this.grade = grade;
}
}
class Student implements Comparable<Student> {
String Name;
String id;
String classId;
public String getId() {
return id;
}
public String getName() {
return Name;
}
public String getclassId() {
return classId;
}
public Student(String classId, String id, String Name) {
this.classId = classId;
this.id = id;
this.Name = Name;
}
public int compareTo(Student stu) {
return getId().compareTo(stu.getId());
}
}
class Course implements Comparable<Course> {
String courseName;
String type;
String testType;
public Course() {
}
public Course(String courseName, String type, String testType) {
this.courseName = courseName;
this.type = type;
this.testType = testType;
}
public String getCourseName() {
return courseName;
}
public String getType() {
return type;
}
public String getTestType() {
return testType;
}
@Override
public int compareTo(Course o) {
Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
return compare.compare(courseName, o.getCourseName());
}
}
class Class implements Comparable<Class> {
String classId;
public Class() {
}
public String getClassId() {
return classId;
}
public Class(String classId) {
this.classId = classId;
}
@Override
public int compareTo(Class o) {
return getClassId().compareTo(o.getClassId());
}
}
abstract class Grade {
int finalGrade;
int usualGrade=0;
public abstract int getTotalGrade();
public Grade() {
}
}
class ExamGrade extends Grade {
public ExamGrade(int usualGrade, int finalGrade) {
this.usualGrade = usualGrade;
this.finalGrade = finalGrade;
}
public int getUsualGrade(){
return usualGrade;
}
public int getTotalGrade() {
return (int) (usualGrade * 0.3 + finalGrade * 0.7);
}
}
class AssessGrade extends Grade {
public AssessGrade(int finalGrade) {
this.finalGrade = finalGrade;
}
public int getTotalGrade() {
return finalGrade;
}
}
class TestGrade extends Grade {
int count;
int add = 0;
public int getTotalGrade() {
return (int) (1.0 * add / count);
}
}
类图：
该题主要考察对输入格式结构的保存以及类的设计，分别使用
static ArrayList<Student> studentList = new ArrayList<>();
static ArrayList<Course> courseList = new ArrayList<>();
static ArrayList<Class> classList = new ArrayList<>();
static ArrayList<ChooseCourse> chooseCourseList = new ArrayList<>();
来存储不同数据。再通过正则表达式对输入条件进行判断。
数据的排序是在类中实现Comparable<>然后重写compareTo方法
7-4 动物发声模拟器（多态）
作者 刘凤良
单位 天津仁爱学院
设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩
其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。
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);
}
public static void speak(Animal animal) {
System.out.println(animal.getAnimalClass() + "的叫声：" + animal.shout());
}
}
abstract class Animal {
public abstract String getAnimalClass();
public abstract String shout();
}
class Dog extends Animal {
public String getAnimalClass() {
return "狗";
}
public String shout() {
return "汪汪";
}
}
class Cat extends Animal {
public String getAnimalClass() {
return "猫";
}
public String shout() {
return "喵喵";
}
}
class Goat extends Animal {
public String getAnimalClass() {
return "山羊";
}
public String shout() {
return "咩咩";
}
}
该题主要是对多态的基础学习
7-1 容器-ArrayList-排序
作者 蔡轲
单位 南昌航空大学
题目描述
编辑
输入多个学生的成绩信息，包括：学号、姓名、数学成绩、物理成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
要求：使用ArrayList存储学生信息。
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+数学成绩+英文空格+物理成绩
以“end”为输入结束标志
输出格式:
按数学/物理成绩之和从高到低的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+数学/物理成绩之和
成绩相同的情况，按输入的先后顺序输出。
输入样例:
在这里给出一组输入。例如：
20201124 张少军 83 75
20201136 李四 78 86
20201118 郑觉先 80 62
end
输出样例:
在这里给出相应的输出。例如：
20201136 李四 164
20201124 张少军 158
20201118 郑觉先 142import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
class Student {
String id;
String name;
int mathScore;
int physicsScore;
public Student(String id, String name, int mathScore, int physicsScore) {
this.id = id;
this.name = name;
this.mathScore = mathScore;
this.physicsScore = physicsScore;
}
public int getTotalScore() {
return mathScore + physicsScore;
}
public String toString() {
return id + " " + name + " " + getTotalScore();
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
ArrayList<Student> students = new ArrayList<>();
while (true) {
String input = scanner.nextLine();
if (input.equals("end")) {
break;
}
String[] a = input.split(" ");
String id = a[0];
String name = a[1];
int mathScore = Integer.parseInt(a[2]);
int physicsScore = Integer.parseInt(a[3]);
Student student = new Student(id, name, mathScore, physicsScore);
students.add(student);
}
Collections.sort(students, new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
return s2.getTotalScore() - s1.getTotalScore();
}
});
for (Student student : students) {
System.out.println(student);
}
}
}
重写够构造器排序方法实现排序
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）成绩平均分只取整数部分，小数部分丢弃
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
static ArrayList<Student> studentList = new ArrayList<>();
static ArrayList<Course> courseList = new ArrayList<>();
static ArrayList<Class> classList = new ArrayList<>();
static ArrayList<ChooseCourse> chooseCourseList = new ArrayList<>();
public static void main(String[] args) {
Scanner indata = new Scanner(System.in);
String sNum = "[0-9]{8}";
String sName = "\\S{1,10}";
String sc = "([1-9]?[0-9]|100)";
String tc = "([4-9])";
String CN = "\\S{1,10}";
String XB = "(选修|必修|实验)";
String SC = "(考试|考察|实验)";
String In1 = CN + " " + XB + " " + SC;
String In2 = sNum + " " + sName + " " + CN + " " +
sc;
String In3 = sNum + " " + sName + " " + CN + " " +
sc + " " + sc;
String In4 = sNum+ " "+sName+ " "+CN +"(\\s([1-9]?[0-9]|100))*";
String In5 =CN + " " + "实验" + " " + "实验"+" "+tc+"(\\s(0*\\.\\d+|1\\.0*|0*\\.\\d*|1\\.0*))*";
String In6 ="C 必修 考试 0.5 0.5";
while (true) {
String a = indata.nextLine();
if (a.matches("end"))
{
break;
}
if(a.matches(In6)){
String[] b = a.split(" ");
String courseName = b[0];//课程名
String type = b[1];//课程类型
String testType = b[2];//课程考试类型
Course course = new Course(courseName, type, testType);
if (conformCourse(courseName) == null) {
courseList.add(course);
}
}
if(a.matches(In5)){
String[] b = a.split(" ");
String courseName = b[0];//课程名
String type = b[1];//课程类型
String testType = b[2];//课程考试类型
Course course = new Course(courseName, type, testType);
course.count=Integer.parseInt(b[3]);
course.point =new ArrayList<>();
if (conformCourse(courseName) == null) {
if(b.length!=(Integer.parseInt(b[3])+4)){
System.out.println(b[0]+" : number of scores does not match");
}
else {
int countPoint = Integer.parseInt(b[3]);
double total = 0;
for (int i = 1; i <=countPoint; i++) {
course.point.add(Double.parseDouble(b[3 + i]));
total += Double.parseDouble(b[3 + i]);
}
if (Math.abs(total -1)<0.0001) {
courseList.add(course);
} else {
System.out.println(b[0] + " : weight value error");
}
}
}
}
if (a.matches(In1)) {
String[] b = a.split(" ");
String courseName = b[0];//课程名
String type = b[1];//课程类型
String testType = b[2];//课程考试类型
Course course = new Course(courseName, type, testType);
if(b[1].matches("必修")&&b[2].matches("考试")){
if (conformCourse(courseName) == null) {
courseList.add(course);
}
}
else if(b[1].matches("选修")&&b[2].matches("考试")){
if (conformCourse(courseName) == null) {
courseList.add(course);
}
}
else if(b[1].matches("选修")&&b[2].matches("考察")){
if (conformCourse(courseName) == null) {
courseList.add(course);
}
}
else if(b[1].matches("实验")&&b[2].matches("实验")){
if (conformCourse(courseName) == null) {
courseList.add(course);
}
}
else{
System.out.println(course.getCourseName()+" : course type & access mode mismatch");
}
}
if (a.matches(In2)) {
String[] b = a.split(" ");
String stuId = b[0];//学生学号
String classID = b[0].substring(0, 6);
String name = b[1];//学生姓名
String courseName = b[2];//课程名字
if (conformClass(classID) == null) {
Class class1 = new Class(classID);
classList.add(class1);
}
Student stu = new Student(classID, stuId, name);
if (!conformStudent(stuId)) {
studentList.add(stu);
}
if (conformCourse(courseName) == null) {
System.out.println(courseName + " " + "does not exist");
}
if (conformCourse(courseName) != null) {
Course course = conformCourse(courseName);
if (course.testType.equals("考察")) {
int finalGrade = Integer.parseInt(b[3]);
AssessGrade assessGrade = new AssessGrade(finalGrade);
ChooseCourse chooseCourse = new ChooseCourse(course, stu, assessGrade);
if (!conformChooseCourse(name, courseName))
chooseCourseList.add(chooseCourse);
} else {
// System.out.println(stuId + " " + name + " " + ": access mode mismatch");
}
}
}
if (a.matches(In3)) {
String[] b = a.split(" ");
String stuId = b[0];//学生学号
String classID = b[0].substring(0, 6);
String name = b[1];//学生姓名
String courseName = b[2];//课程名字
if (conformClass(classID) == null) {
Class class1 = new Class(classID);
classList.add(class1);
}
Student stu = new Student(classID, stuId, name);
if (!conformStudent(stuId)) {
studentList.add(stu);
}
if (conformCourse(courseName) == null) {
System.out.println(courseName + " " + "does not exist");
}
if (conformCourse(courseName) != null) {
Course course = conformCourse(courseName);
if (course.testType.equals("考试")) {
int usualGrade = Integer.parseInt(b[3]);
int finalGrade = Integer.parseInt(b[4]);
ExamGrade examGrade = new ExamGrade(usualGrade, finalGrade);
ChooseCourse chooseCourse = new ChooseCourse(course, stu, examGrade);
if (!conformChooseCourse(name, courseName))
chooseCourseList.add(chooseCourse);
} else {
//System.out.println(stuId + " " + name + " " + ": access mode mismatch");
}
}
}
if (a.matches(In4)) {
String[] b = a.split(" ");
String stuId = b[0];
String classID = b[0].substring(0, 6);
String name = b[1];
String courseName = b[2];
String n = b[3];
int num = Integer.parseInt(b[3]);
if (conformClass(classID) == null) {
Class class1 = new Class(classID);
classList.add(class1);
}
Student stu = new Student(classID, stuId, name);
if (!conformStudent(stuId)) {
studentList.add(stu);
}
if (conformCourse(courseName) == null) {
System.out.println(courseName + " " + "does not exist");
}
if (conformCourse(courseName) != null) {
Course course = conformCourse(courseName);
if (b.length == (course.count+3)) {
TestGrade testGrade = new TestGrade();
for(int j=0;j<course.count;j++){
testGrade.add = testGrade.add + Integer.parseInt(b[3+j])*course.point.get(j) ;
}
testGrade.count = course.count;
ChooseCourse chooseCourse = new ChooseCourse(course, stu, testGrade);
if (!conformChooseCourse(name, courseName))
chooseCourseList.add(chooseCourse);
}
else {
System.out.println(b[0] + " " + b[1] + " : access mode mismatch");
}
}
}
if(!a.matches(In1)&&!a.matches(In2)&&!a.matches(In3)&&!a.matches(In4)&&!a.matches(In5)){
System.out.println("wrong format");
}
}
printStudents();
printCourses();
printClasses();
}
public static Course conformCourse(String name) {
for (Course course : courseList) {
if (course.getCourseName().equals(name))
return course;
}
return null;
}
public static Class conformClass(String classId) {
for (Class cls : classList) {
if (cls.getClassId().equals(classId))
return cls;
}
return null;
}
public static boolean conformStudent(String id) {
for (Student student : studentList) {
if (student.getId().equals(id))
return true;
}
return false;
}
public static boolean conformChooseCourse(String stuName, String courseName) {
for (ChooseCourse cs : chooseCourseList) {
if (cs.student.getName().equals(stuName) && cs.course.getCourseName().equals(courseName))
return true;
}
return false;
}
public static void printStudents(){
Collections.sort(studentList);
for(int i=0;i<studentList.size();i++){
Student stu=studentList.get(i);
ArrayList<ChooseCourse> stuCourseSelects=getStudentSelects(stu.getId());
if(stuCourseSelects.size()!=0) {
System.out.println(stu.getId()+" "+stu.getName()+" "+getAvgTotalScore(stuCourseSelects));
}
else if(stuCourseSelects.size()==0){
System.out.println(stu.getId()+" "+stu.getName()+" "+"did not take any exams");
}
}
}
public static ArrayList<ChooseCourse> getStudentSelects(String id) {
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse cos : chooseCourseList) {
if (cos.student.getId().equals(id))
choose.add(cos);
}
return choose;
}
public static int getAvgTotalScore(ArrayList<ChooseCourse> cs){
int average=0;
int sum=0;
for(ChooseCourse c:cs){
sum+=c.grade.getTotalGrade();
}
average=sum/cs.size();
return average;
}
public static void printCourses(){
Collections.sort(courseList);
for(int i=0;i<courseList.size();i++){
Course course=courseList.get(i);
ArrayList<ChooseCourse> stuCourseSelects=getCourseSelects(course.getCourseName());
if(stuCourseSelects.size()!=0){
if(course.testType.equals("考试"))
System.out.println(course.getCourseName()+" "+getAvgUsualScore(stuCourseSelects)+" "+getAvgFinalScore(stuCourseSelects)+" "+getAvgTotalScore(stuCourseSelects));
if(course.testType.equals("考察"))
System.out.println(course.getCourseName()+" "+getAvgFinalScore(stuCourseSelects)+" "+getAvgTotalScore(stuCourseSelects));
if(course.testType.equals("实验"))
System.out.println(course.getCourseName()+" "+getAvgTotalScore(stuCourseSelects));
}
else if(stuCourseSelects.size()==0){
System.out.println(course.courseName+" "+"has no grades yet");
}
}
}
public static ArrayList<ChooseCourse> getCourseSelects(String courseName) {
ArrayList<ChooseCourse> choose = new ArrayList<>();
for (ChooseCourse cs : chooseCourseList) {
if (cs.course.getCourseName().equals(courseName))
choose.add(cs);
}
return choose;
}
public static int getAvgUsualScore(ArrayList<ChooseCourse> cs){
int average=0;
int sum=0;
for(ChooseCourse c:cs){
if(c.course.getTestType().equals("考试")){
sum+=c.grade.usualGrade;
}
}
average=sum/cs.size();
return average;
}
public static int getAvgFinalScore(ArrayList<ChooseCourse> cs){
int average=0;
int sum=0;
for(ChooseCourse c:cs){
sum+=c.grade.finalGrade;
}
average=sum/cs.size();
return average;
}
public static void printClasses() {
Collections.sort(classList);
for (int i = 0; i < classList.size(); i++) {
Class cl = classList.get(i);
ArrayList<ChooseCourse> stuCourseSelects = getClassSelects(cl.getClassId());
if (stuCourseSelects.size() != 0) {
System.out.println(cl.getClassId() + " " + getAvgTotalScore(stuCourseSelects));
} else if (stuCourseSelects.size() == 0) {
System.out.println(cl.getClassId() + " " + "has no grades yet");
}
}
}
public static ArrayList<ChooseCourse> getClassSelects(String clsId){
ArrayList<ChooseCourse> choose =new ArrayList<>();
for(ChooseCourse cos:chooseCourseList) {
if (cos.student.getclassId().equals(clsId))
choose.add(cos);
}
return choose;
}
}
class ChooseCourse {
Course course;
Student student;
Grade grade;
public ChooseCourse(Course course, Student student, Grade grade) {
this.course = course;
this.student = student;
this.grade = grade;
}
}
class Student implements Comparable<Student> {
String Name;
String id;
String classId;
public String getId() {
return id;
}
public String getName() {
return Name;
}
public String getclassId() {
return classId;
}
public Student(String classId, String id, String Name) {
this.classId = classId;
this.id = id;
this.Name = Name;
}
public int compareTo(Student stu) {
return getId().compareTo(stu.getId());
}
}
class Course implements Comparable<Course> {
String courseName;
String type;
String testType;
ArrayList<Double> point;
int count;
public Course() {
}
public Course(String courseName, String type, String testType) {
this.courseName = courseName;
this.type = type;
this.testType = testType;
}
public String getCourseName() {
return courseName;
}
public String getType() {
return type;
}
public String getTestType() {
return testType;
}
@Override
public int compareTo(Course o) {
Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
return compare.compare(courseName, o.getCourseName());
}
}
class Class implements Comparable<Class> {
String classId;
public Class() {
}
public String getClassId() {
return classId;
}
public Class(String classId) {
this.classId = classId;
}
@Override
public int compareTo(Class o) {
return getClassId().compareTo(o.getClassId());
}
}
abstract class Grade {
int finalGrade;
int usualGrade=0;
public abstract int getTotalGrade();
public Grade() {
}
}
class ExamGrade extends Grade {
public ExamGrade(int usualGrade, int finalGrade) {
this.usualGrade = usualGrade;
this.finalGrade = finalGrade;
}
public int getUsualGrade(){
return usualGrade;
}
public int getTotalGrade() {
return (int) (usualGrade * 0.3 + finalGrade * 0.7);
}
}
class AssessGrade extends Grade {
public AssessGrade(int finalGrade) {
this.finalGrade = finalGrade;
}
public int getTotalGrade() {
return finalGrade;
}
}
class TestGrade extends Grade {
int count;
double add = 0;
public int getTotalGrade() {
return (int) (1.0 * add );
}
}
该题与pta成绩统计2类似，添加class TestGrade extends Grade 以及重写了正则表达式完成对应功能
7-3 jmu-Java-02基本语法-03-身份证排序
分数 9
作者 郑如滨
单位 集美大学
- 输入n，然后连续输入n个身份证号。
- 然后根据输入的是sort1还是sort2，执行不同的功能。输入的不是sort1或sort2，则输出
exit并退出。
输入sort1，将每个身份证的年月日抽取出来，按年-月-日格式组装，然后对组装后的年-月-日升序输出。
输入sort2，将所有身份证按照里面的年月日升序输出。
注意：处理输入的时候，全部使用Scanner的nextLine()方法，以免出错。
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = Integer.parseInt(scanner.nextLine());
ArrayList<String> ids = new ArrayList<>();
for (int i = 0; i < n; i++) {
ids.add(scanner.nextLine());
}
while (true) {
String command = scanner.nextLine();
if (command.equals("sort1")) {
ArrayList<String> sortedDates = new ArrayList<>();
for (String id : ids) {
String year = id.substring(6, 10);
String month = id.substring(10, 12);
String day = id.substring(12, 14);
sortedDates.add(year + "-" + month + "-" + day);
}
Collections.sort(sortedDates);
for (String date : sortedDates) {
System.out.println(date);
}
} else if (command.equals("sort2")) {
Collections.sort(ids, (id1, id2) -> {
String date1 = id1.substring(6, 14);
String date2 = id2.substring(6, 14);
return date1.compareTo(date2);
});
for (String id : ids) {
System.out.println(id);
}
} else {
System.out.println("exit");
return;
}
}
}
}
原理也是重写构造器排序方法，这里使用了Lambda表达式来重写 new Comparator
Collections.sort(ids, (id1, id2) -> {
String date1 = id1.substring(6, 14);
String date2 = id2.substring(6, 14);
return date1.compareTo(date2);
7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
分数 10
作者 郑如滨
单位 集美大学
定义IntegerStack接口，用于声明一个存放Integer元素的栈的常见方法:
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(); //返回栈中元素个数
定义IntegerStack的实现类ArrayIntegerStack，内部使用数组实现。创建时，可指定内部数组大小。
main方法说明
- 输入n，建立可包含n个元素的ArrayIntegerStack对象
- 输入m个值，均入栈。每次入栈均打印入栈返回结果。
- 输出栈顶元素，输出是否为空，输出size
- 使用Arrays.toString()输出内部数组中的值。
- 输入x，然后出栈x次，每次出栈均打印。
- 输出栈顶元素，输出是否为空，输出size
- 使用Arrays.toString()输出内部数组中的值。
思考
如果IntegerStack接口的实现类内部使用ArrayList来存储元素，怎么实现？测试代码需要进行什么修改？
import java.util.Arrays;
import java.util.Scanner;
interface IntegerStack {
Integer push(Integer item);
Integer pop();
Integer peek();
boolean empty();
int size();
}
class ArrayIntegerStack implements IntegerStack {
private Integer[] stack;
private int top;
public ArrayIntegerStack(int capacity) {
stack = new Integer[capacity];
top = -1;
}
@Override
public Integer push(Integer item) {
if (item == null || top == stack.length - 1) {
return null;
}
stack[++top] = item;
return item;
}
@Override
public Integer pop() {
if (empty()) {
return null;
}
return stack[top--];
}
@Override
public Integer peek() {
if (empty()) {
return null;
}
return stack[top];
}
@Override
public boolean empty() {
return top == -1;
}
@Override
public int size() {
return top + 1;
}
@Override
public String toString() {
return Arrays.toString(stack) ;
}
}
class Main{
public static void main(String[] args) {
Scanner indata =new Scanner(System.in);
ArrayIntegerStack stack = new ArrayIntegerStack(Integer.parseInt(indata.nextLine()));
int n = Integer.parseInt(indata.nextLine()); // 输入n
for (int i = 0; i < n; i++) {
int value = indata.nextInt(); // 输入m个值
System.out.println(stack.push(value));
}
System.out.println(stack.peek() + ","+stack.empty() + "," + stack.size());
System.out.println(stack.toString());
int x = indata.nextInt(); // 输入x
for (int i = 0; i < x; i++) {
System.out.println(stack.pop());
}
System.out.println(stack.peek() + ","+stack.empty() + "," + stack.size());
System.out.println(stack.toString());
}
}
该题是对接口的熟悉，通过接口来构建一个栈的用法
7-5 jmu-Java-03面向对象基础-05-覆盖
作者 郑如滨
单位 集美大学
Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。
1. 新建PersonOverride类
a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。
b. 有参构造方法，参数为name, age, gender
c. 无参构造方法，使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,true
d.toString()方法返回格式为：name-age-gender
e. equals方法需比较name、age、gender，这三者内容都相同，才返回true.
2. main方法
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的所有构造方法。
提示：使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。
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;
}
@Override
public String toString() {
return name + "-" + age + "-" + gender;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
PersonOverride person = (PersonOverride) obj;
return age == person.age && gender == person.gender && name.equals(person.name);
}
}
class Main{
public static void main(String[] args) {
ArrayList<PersonOverride> persons1 = new ArrayList<>();
ArrayList<PersonOverride> persons2 = new ArrayList<>();
Scanner s =new Scanner(System.in);
int n1=Integer.parseInt(s.nextLine()) ;
for (int i = 0; i < n1; i++) {
persons1.add(new PersonOverride());
}
int n2 = Integer.parseInt(s.nextLine());
for (int i = 0; i < n2; i++) {
String input = s.nextLine();
String[] inputs = input.split(" ");
PersonOverride newPerson = new PersonOverride(inputs[0], Integer.parseInt(inputs[1]), Boolean.parseBoolean(inputs[2]));
boolean exists = false;
for (PersonOverride person : persons2) {
if (person.equals(newPerson)) {
exists = true;
break;
}
}
if (!exists) {
persons2.add(newPerson);
}
}
for (PersonOverride person : persons1) {
System.out.println(person.toString());
}
for (PersonOverride person : persons2) {
System.out.println(person.toString());
}
System.out.println(persons2.size());
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
}
}
通过该题熟悉了Object类中toString和equal方法的重写
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)
进行小数位数控制。
import java.util.Scanner;
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) {
System.out.println(String.format("%.2f", solid.getArea()));
System.out.println( String.format("%.2f", solid.getVolume()));
}
}
abstract class Solid {
public abstract double getArea();
public abstract double getVolume();
}
class Cube extends Solid {
private double side;
public Cube(double side) {
this.side = side;
}
@Override
public double getArea() {
return 6 * side * side;
}
@Override
public double getVolume() {
return side * side * side;
}
}
class RegularPyramid extends Solid {
private double side;
public RegularPyramid(double side) {
this.side = side;
}
@Override
public double getArea() {
return Math.sqrt(3) * side * side;
}
@Override
public double getVolume() {
return Math.pow(side, 3) / (6 * Math.sqrt(2));
}
}
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类中定义的静态方法，用户输出魔方的信息，用于体现多态性。
import java.util.Scanner;
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.println( String.format("%.2f", cube.getArea()));
System.out.println(String.format("%.2f", cube.getVolume()));
}
}
abstract class Solid {
public abstract double getArea();
public abstract double getVolume();
}
class Cube extends Solid {
private double side;
public Cube(double side) {
this.side = side;
}
@Override
public double getArea() {
return 6 * side * side;
}
public double getSide() {
return side;
}
@Override
public double getVolume() {
return side * side * side;
}
}
class RegularPyramid extends Solid {
private double side;
public RegularPyramid(double side) {
this.side = side;
}
public double getSide() {
return side;
}
@Override
public double getArea() {
return Math.sqrt(3) * side * side;
}
@Override
public double getVolume() {
return Math.pow(side, 3) / (6 * Math.sqrt(2));
}
}
abstract class RubikCube {
private String color;
private int layer;
private double unitSideLength;
public RubikCube(String color, int layer, double unitSideLength) {
this.color = color;
this.layer = layer;
this.unitSideLength = unitSideLength;
}
public String getColor() {
return color;
}
public int getLayer() {
return layer;
}
public double getUnitSideLength() {
return unitSideLength;
}
public abstract double getArea();
public abstract double getVolume();
}
class SquareCube extends RubikCube {
private Cube cube;
public SquareCube(String color, int layer, Cube cube) {
super(color, layer, cube.getSide());
this.cube = cube;
}
@Override
public double getArea() {
return 6 * Math.pow(getUnitSideLength() * getLayer(), 2);
}
@Override
public double getVolume() {
return Math.pow(getUnitSideLength() * getLayer(), 3);
}
}
class RegularPyramidCube extends RubikCube {
private RegularPyramid pyramid;
public RegularPyramidCube(String color, int layer, RegularPyramid pyramid) {
super(color, layer, pyramid.getSide());
this.pyramid = pyramid;
}
@Override
public double getArea() {
return Math.sqrt(3) * getUnitSideLength() * getLayer()*getUnitSideLength()* getLayer();
}
@Override
public double getVolume() {
return Math.pow((getUnitSideLength() * getLayer()), 3) / (6 * Math.sqrt(2));
}
}
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.38import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
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("");
}
}
public static void display(RubikCube cube) {
System.out.println(cube.getColor());
System.out.println( String.format("%.2f", cube.getArea()));
System.out.println(String.format("%.2f", cube.getVolume()));
}
}
abstract class Solid {
public abstract double getArea();
public abstract double getVolume();
}
class Cube extends Solid {
private double side;
public Cube(double side) {
this.side = side;
}
@Override
public double getArea() {
return 6 * side * side;
}
public double getSide() {
return side;
}
@Override
public double getVolume() {
return side * side * side;
}
}
class RegularPyramid extends Solid {
private double side;
public RegularPyramid(double side) {
this.side = side;
}
public double getSide() {
return side;
}
@Override
public double getArea() {
return Math.sqrt(3) * side * side;
}
@Override
public double getVolume() {
return Math.pow(side, 3) / (6 * Math.sqrt(2));
}
}
abstract class RubikCube implements Comparable<RubikCube>{
private String color;
private int layer;
private double unitSideLength;
public RubikCube(String color, int layer, double unitSideLength) {
this.color = color;
this.layer = layer;
this.unitSideLength = unitSideLength;
}
public String getColor() {
return color;
}
public int getLayer() {
return layer;
}
public double getUnitSideLength() {
return unitSideLength;
}
public abstract double getArea();
public abstract double getVolume();
public int compareTo(RubikCube o) {
return Double.compare(this.getVolume(), o.getVolume());
}
}
class SquareCube extends RubikCube {
private Cube cube;
public SquareCube(String color, int layer, Cube cube) {
super(color, layer, cube.getSide());
this.cube = cube;
}
@Override
public double getArea() {
return 6 * Math.pow(getUnitSideLength() * getLayer(), 2);
}
@Override
public double getVolume() {
return Math.pow(getUnitSideLength() * getLayer(), 3);
}
}
class RegularPyramidCube extends RubikCube {
private RegularPyramid pyramid;
public RegularPyramidCube(String color, int layer, RegularPyramid pyramid) {
super(color, layer, pyramid.getSide());
this.pyramid = pyramid;
}
@Override
public double getArea() {
return Math.sqrt(3) * getUnitSideLength() * getLayer()*getUnitSideLength()* getLayer();
}
@Override
public double getVolume() {
return Math.pow((getUnitSideLength() * getLayer()), 3) / (6 * Math.sqrt(2));
}
}
7-4 销售步枪问题（附加题）
分数 10
作者 段喜龙
单位 南昌航空大学
前亚利桑那州境内的一位步枪销售商销售密苏里州制造的步枪机（lock）、枪托（stock）和枪管（barrel）。枪机卖45美元，枪托卖30美元，枪管卖25美元。销售商每月至少要售出一支完整的步枪，且生产限额是销售商在一个月内可销售70个枪机、80个枪托和90个枪管。
根据每个月的销售情况，计算销售商的佣金（提成）算法如下：
-
不到（含）1000美元的部分为10%；
-
1000（含）~1800美元的部分为15%；
-
超过1800美元的部分为20%。
佣金程序生成月份销售报告，汇总销售商的销售总额和佣金。
编程要求：必须符合面向对象编程，且保证类设计的单一职责模式，使用面向过程编程判定0分。
提示：可以设置一个销售订单类。参考类图如下：
输入格式:
输入销售商每个月售出枪机、枪托、枪管的数量，可以用空格或者回车分隔。
输出格式:
分别输出销售商在该月的销售额和佣金，中间用空格分开。
输入样例1:
在这里给出一组输入。例如：
30 40 50
输出样例1:
在这里给出相应的输出。例如：
3800.00 620.00
输入样例2:
在这里给出一组输入。例如：
88 56 98
输出样例2:
在这里给出相应的输出。例如：
Wrong Formatimport java.util.Scanner;
class SalesOrder {
private int lockNum;
private int stockNum;
private int barrelNum;
public SalesOrder(int lockNum, int stockNum, int barrelNum) {
this.lockNum = lockNum;
this.stockNum = stockNum;
this.barrelNum = barrelNum;
}
public double getTotal() {
double lockAmount = lockNum * 45;
double stockAmount = stockNum * 30;
double barrelAmount = barrelNum * 25;
return lockAmount + stockAmount + barrelAmount;
}
public double getCommission() {
double salesAmount = getTotal();
if (salesAmount < 1000) {
return salesAmount * 0.10;
} else if (1000<=salesAmount&&salesAmount <1800) {
return 1000 * 0.10 + (salesAmount - 1000) * 0.15;
} else {
return 1000 * 0.10 + 800 * 0.15 + (salesAmount - 1800) * 0.20;
}
}
}
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int lockNum = input.nextInt();
int stockNum = input.nextInt();
int barrelNum = input.nextInt();
if (lockNum >70 || stockNum>80 || barrelNum >90||lockNum <=0||stockNum <=0|| barrelNum<=0) {
System.out.println("Wrong Format");
} else {
SalesOrder order = new SalesOrder(lockNum, stockNum, barrelNum);
double salesAmount = order.getTotal();
double commission = order.getCommission();
System.out.printf("%.2f %.2f%n", salesAmount, commission);
}
}
}
期末考试题集主要还是对类的构建以及多态，继承的加深理解，还考察了排序的重写
三.踩坑心得
1.注意题目给出的精度要求，很多时候答案错误都是精度引起的
2.类名，变量名要规范不然很容易忘记自己前面写的代码含义，之后的修改工作若不规范则很困难
3.输入的正则表达式构思时要细致，有些时候构造的不同正则表达式之间可能有包含关系，影响代码逻辑
4.要学会用lambda表达式，很多时候使用lambda表达式可以节省很多代码量，以及保证了程序的可读性
5.多使用静态方法去减少重复代码量，保证程序的简洁
四.改进与建议
1.有些复杂的测试点可以在pta中给出输入输出案例
2.可以多讲讲常用设计模式在日常项目中的使用，以及java网络编程一些相关知识
五.总结
在后面的课程里主要是设计模式的学习，它让我意识到软件设计不仅仅关注实现功能，更重要的是关注软件的可扩展性，可维护性和可重用性。良好的设计能够提高代码的质量和复用性。
主要设计模式包括单例模式、工厂模式、观察者模式、策略模式、责任链模式、模板方法模式、适配器模式、外观模式、代理模式等。这些模式提供了通用且优秀的解决方案，在实际项目开发中广泛应用。
与此同时Java基础语法学习让我掌握了面向对象思想、类和对象的定义、继承和多态、异常处理、泛型、注解、集合框架、IO流等知识。这为后续开发 打下了坚实的基础。
代码应注重可读性和可维护性。使用合理的封装、继承和多态可以提高代码的灵活性和复用性。异常处理可以提高程序的鲁棒性。JDK提供了丰富的类库，应该充分利用。
以后项目开发应按照分层设计原则，将功能细分为合理的模块。使用合适的设计模式可以提高系统的扩展性。测试驱动开发可以提高代码质量。
同时多线程的学习和javafx库也让我体会到的java的强大之处，后一个月不仅仅只是以上题集的学习，更多的是对java其他功能的了解，也让我明白java不仅仅重要的是语法，重要的而是我们对其实现功能库的了解。
pta7,8和期末题集让我在理解继承封装多态的基础上对接口，构造器，hashmap，treemap，和set有了更深刻的理解。在以后的学习过程中，可能会对其他功能去学习与了解，如jdbc对数据库的连接，socket网络编程等。
以及在对应架构中如spring boot，spring MVC中加强java在实际工程中的理解。
浙公网安备 33010602011771号