PTA7-8次PTA题目集以及期末考试总结
一、前言：
本次博客介绍PTA第七次和第八次作业以及期末考试的总结。
第七次题目有涉及到容器HashMap的检索与排序，其中还有特殊的HashMap来存储内容，同时还有多态的使用与学习，可以让你对多态有进一步的了 解，对于成绩的迭代二，其中需要重构类图，新增了一些类以及实现方法，熟练的运用类与类的接口来实现他们之间的排序来更好的解决问题，本次题目集的题目量比较少，难度并不高。 第八次题目涉及到了ArrayList的排序方法，以及for-each，同时还涉及到了自定义接口来使用，对于接口中各个方法的重写等，以及对于toString与equals方法的覆盖等，程成绩统计程序-3在第二次基
础上修改了计算总成绩的方式，要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个构成
期末考试主要考的还是类的继承和多态的关系以及一些接口的实现。于编程题部分，主要是让我们规范的构造类以确保代码具有一定的拓展性，确保后续的使用，其中还让我们使用到了接口用接口方法
来实现排序，题目不是很难，但是想要在有限的时间里完成选择题和编程大题还是有一点难度的。
二、程序设计与分析：
第七次作业：
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）成绩平均分只取整数部分，小数部分丢弃
参考类图（与第一次相同，其余内容自行补充）：
程序分析：
第八次作业：
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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.Collator;
import java.util.*;
import java.util.stream.Collectors;
class student_message{
Class classes;
Student students;
Course courses;
public student_message() {
}
public student_message(Class classes, Student students, Course courses) {
this.classes = classes;
this.students = students;
this.courses = courses;
}
}
class Class extends student_message{
String classNum;
HashMap<String, Student> students;
Class(String classNum) {
this.classNum = classNum;
}
public String get_ClassNum() {
return classNum;
}
}
class Student extends student_message{
String name;
String studentNum;
Student(String name, String studentNum) {
this.name = name;
this.studentNum = studentNum;
}
public String getName() {
return name;
}
public String getStudentNum() {
return studentNum;
}
}
class Course extends student_message {
String className;
int courseid1;
int courseid2;
ArrayList<Float> course_classProcess = new ArrayList<>();
Course(String className, int courseid1, int courseid2) {
this.className = className;
}
public String getClassName() {
return className;
}
}
class CourseSelection {
Student student;
Course course;
Grade grade;
}
class Grade {
ArrayList<Integer> grades = new ArrayList<>();
ArrayList<Float> stuiate_grade = new ArrayList<>();
public int getGrade() {
float allGrades = 0;
for (int i = 0; i < stuiate_grade.size(); i++) {
allGrades += stuiate_grade.get(i) * grades.get(i);
}
return (int) allGrades;
}
}
abstract class Print {
abstract public void studentPrint(HashMap<String, Student> students, ArrayList<CourseSelection> courseSelections);
abstract public void coursePrint(HashMap<String, Course> courses, ArrayList<CourseSelection> courseSelections);
abstract public void classPrint(HashMap<String, Class> classes, ArrayList<CourseSelection> courseSelections);
}
class printer extends Print {
public void studentPrint(HashMap<String, Student> students, ArrayList<CourseSelection> courseSelections) {
Set<String> set = students.keySet();
Object[] arr = set.toArray();
Arrays.sort(arr);
student_process(arr, courseSelections, students);
}
public void student_process(Object[] arr, ArrayList<CourseSelection> courseSelections, HashMap<String, Student> students) {
for (Object key : arr) {
int x = 0, y = 0, z = -1;
for (CourseSelection courseSelection : courseSelections) {
if (students.get(key).getStudentNum().equals(courseSelection.student.getStudentNum())) {
z = 0;
x += courseSelection.grade.getGrade();
y++;
}
}
if (z == -1) {
System.out.println(students.get(key).getStudentNum() + " " + students.get(key).getName() + " did not take any exams");
}
if (z == 0) {
x = x / y;
System.out.println(students.get(key).getStudentNum() + " " + students.get(key).getName() + " " + x);
}
}
}
public void coursePrint(HashMap<String, Course> courses, ArrayList<CourseSelection> courseSelections) {
List<String> list = courses.keySet().stream().collect(Collectors.toList());
Collections.sort(list, new SoftName());
course_process(list, courseSelections, courses);
}
public void course_process(List<String> list, ArrayList<CourseSelection> courseSelections, HashMap<String, Course> courses) {
for (String key : list) {
int x = 0, y = 0, z = -1;
for (CourseSelection courseSelection : courseSelections) {
if (courses.get(key).getClassName().equals(courseSelection.course.getClassName())) {
z = 0;
x += courseSelection.grade.getGrade();
y++;
}
}
if (z == -1) {
System.out.println(courses.get(key).getClassName() + " has no grades yet");
}
if (z == 0) {
x = x / y;
System.out.println(courses.get(key).getClassName() + " " + x);
}
}
}
public void classPrint(HashMap<String, Class> classes, ArrayList<CourseSelection> courseSelections) {
Set<String> set = classes.keySet();
Object[] arr = set.toArray();
Arrays.sort(arr);
class_process(arr, courseSelections, classes);
}
public void class_process(Object[] arr, ArrayList<CourseSelection> courseSelections, HashMap<String, Class> classes) {
for (Object key : arr) {
int x = 0, y = 0, z = -1;
for (CourseSelection courseSelection : courseSelections) {
if (classes.get(key).students.containsKey(courseSelection.student.getStudentNum())) {
z = 0;
x += courseSelection.grade.getGrade();
y++;
}
}
if (z == -1) {
System.out.println(classes.get(key).get_ClassNum() + " has no grades yet");
}
if (z == 0) {
x = x / y;
System.out.println(classes.get(key).get_ClassNum() + " " + x);
}
}
}
static class SoftName implements Comparator<String> {
public int compare(String name1, String name2) {
Comparator<Object> compare = Collator.getInstance(Locale.CHINA);
return compare.compare(name1, name2);
}
}
}
abstract class Course_Process{
abstract public void input_process(String strs);
abstract public void Is_inputype(String[] inputs);
abstract public void Is_inputmode(String[] inputs);
}
class ALL_print extends Course_Process{
printer print;
HashMap<String, student_message> stu = new HashMap<>();
HashMap<String, Class> classes = new HashMap<>();
HashMap<String, Student> students = new HashMap<>();
HashMap<String, Course> courses = new HashMap<>();
ArrayList<CourseSelection> courseSelections = new ArrayList<>();
public void input_process(String strs) {
String[] inputs = strs.split(" ");
if (strs.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)$") ||
strs.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)( )((0.(0)+[1-9]|0.[1-9][0-9]*)( )(0.(0)+[1-9]|0.[1-9][0-9]*)$)") ||
strs.matches("^(\\S{1,10})( )(必修|选修|实验)( )(考试|考察|实验)( )([4-9])((( )(0.(0)+[1-9]|0.[1-9][0-9]*|1))*)(( )(0.(0)+[1-9]|0.[1-9][0-9]*))$")
) {
Is_inputype(inputs);
} else if (strs.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)$") ||
strs.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([0-9]|[1-9][0-9]|100)( )([0-9]|[1-9][0-9]|100)$") ||
strs.matches("^([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )((([0-9]|[1-9][0-9]|100)( ))*)([0-9]|[1-9][0-9]|100)$")
) {
Is_inputmode(inputs);
} else
System.out.println("wrong format");
}
public void Is_inputype(String[] inputs) {
if (courses.containsKey(inputs[0])) {
return;
}
int i = 0, j = 0;
if (inputs[1].equals("必修")) {
i = 1;
}
if (inputs[1].equals("选修")) {
i = 2;
}
if (inputs[1].equals("实验")) {
i = 3;
}
if (inputs[2].equals("考试")) {
j = 1;
}
if (inputs[2].equals("考察")) {
j = 2;
}
if (inputs[2].equals("实验")) {
j = 3;
}
if ((i == 1 && j != 1) || (i == 3 && j != 3) || (i != 3 && j == 3)) {
System.out.println(inputs[0] + " : course type & access mode mismatch");
return;
}
if ((j == 1 && inputs.length != 5) || (j == 2 && inputs.length != 3) || (j == 3 && inputs.length - 4 != Integer.parseInt(inputs[3]))) {
System.out.println(inputs[0] + " : number of scores does not match");
return;
}
if (j == 1 && Float.parseFloat(inputs[3]) + Float.parseFloat(inputs[4]) != 1) {
System.out.println(inputs[0] + " : weight value error");
return;
}
if (j == 3) {
float value = 0;
for (int k = 0; k < Integer.parseInt(inputs[3]); k++) {
value += Float.parseFloat(inputs[4 + k]);
}
if (value > 1.001 || value < 0.999) {
System.out.println(inputs[0] + " : weight value error");
return;
}
}
Course course = new Course(inputs[0], i, j);
if (j == 1) {
course.course_classProcess.add(Float.parseFloat(inputs[3]));
course.course_classProcess.add(Float.parseFloat(inputs[4]));
}
if (j == 2)
course.course_classProcess.add(1F);
if (j == 3) {
for (int k = 0; k < Integer.parseInt(inputs[3]); k++) {
course.course_classProcess.add(Float.parseFloat(inputs[4 + k]));
}
}
courses.put(inputs[0], course);
}
public void Is_inputmode(String[] inputs) {
for (CourseSelection courseSelection : courseSelections) {
if (courseSelection.student.getStudentNum().equals(inputs[0]) && courseSelection.student.getName().equals(inputs[1]) && courseSelection.course.getClassName().equals(inputs[2])) {
return;
}
}
Student student = new Student(inputs[1], inputs[0]);
students.put(inputs[0], student);
String classNum = inputs[0].substring(0, 6);
if (!classes.containsKey(classNum)) {
Class class_num = new Class(classNum);
classes.put(classNum, class_num);
classes.get(classNum).students = new HashMap<>();
}
classes.get(classNum).students.put(student.getStudentNum(), student);
if (!courses.containsKey(inputs[2])) {
System.out.println(inputs[2] + " does not exist");
return;
}
if (inputs.length - 3 != courses.get(inputs[2]).course_classProcess.size()) {
System.out.println(inputs[0] + " " + inputs[1] + " : access mode mismatch");
return;
}
CourseSelection courseSelection = new CourseSelection();
courseSelection.student = student;
courseSelection.course = courses.get(inputs[2]);
Grade grade = new Grade();
for (int i = 0; i < inputs.length - 3; i++) {
grade.grades.add(Integer.parseInt(inputs[3 + i]));
}
grade.stuiate_grade = courses.get(inputs[2]).course_classProcess;
courseSelection.grade = grade;
courseSelections.add(courseSelection);
}
}
public class Main {
static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
static ALL_print allprint = new ALL_print();
public static void main(String[] args) throws IOException {
allprint.print = new printer();
end_printf();
}
public static void end_printf() throws IOException {
for (; ; ) {
String str = in.readLine();
if (str.equals("end")) {
allprint.print.studentPrint(allprint.students, allprint.courseSelections);
allprint.print.coursePrint(allprint.courses, allprint.courseSelections);
allprint.print.classPrint(allprint.classes, allprint.courseSelections);
break;
}
allprint.input_process(str);
}
}
}
期末考试：
7-1 立体图形问题 分数 10 作者 段喜龙 单位 南昌航空大学编程求得正方体和正三棱锥的表面积和体积，要求必须体现扩展性（继承）和多态性。
类结构如下图所示（参考）：
试编程完成如上类设计，主方法源码如下（可直接拷贝使用）：
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
double side = input.nextDouble();
display(new Cube(side));
display(new RegularPyramid(side));
}
其中，display(Solid solid)方法为定义在Main类中的静态方法，作用为体现程序的多态性。
注：正三棱锥的体积计算公式为底面积*高/3。
输入格式:
输入一个实型数，分别作为正方体的边长和正三棱锥的边长。
输出格式:
分别输出正方体的表面积、体积以及正棱锥的表面积和体积。保留两位小数，建议使用String.format(“%.2f”,value)
进行小数位数控制。
输入样例:
在这里给出一组输入。例如：
2.5
输出样例:
在这里给出相应的输出。例如：
37.50 15.63 10.83 1.84
import java.util.Scanner;
public class Main {
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));
}
public static void display(Solid solid){
System.out.println(String.format("%.2f",solid.getarea()));
System.out.println(String.format("%.2f",solid.getvolum()));
}
}
abstract class Solid{
abstract double getarea();
abstract double getvolum();
}
class Cube extends Solid{
double side;
public Cube(double side) {
this.side = side;
}
@Override
double getarea() {
double area=0;
area=side*side*6;
return area;
}
@Override
double getvolum() {
double volum=0;
volum=side*side*side;
return volum;
}
}
class RegularPyramid extends Solid{
double side;
public RegularPyramid(double side) {
this.side = side;
}
@Override
double getarea() {
double baseArea = (Math.sqrt(3) / 4) * side * side;
double lateralArea = 3 * baseArea; // 正三棱锥有三个等边三角形的侧面
return baseArea + lateralArea;
}
@Override
double getvolum() {
return (Math.sqrt(2) / 12) * side * side * side ;
}
}
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.85
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 = 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 rubikCube){
System.out.println(rubikCube.color);
System.out.println(String.format("%.2f",rubikCube.getarea()));
System.out.println(String.format("%.2f",rubikCube.getvolum()));
}
}
abstract class Solid{
double side;
abstract double getarea();
abstract double getvolum();
}
class Cube extends Solid{
double side;
public Cube(double side) {
this.side = side;
}
@Override
double getarea() {
double area=0;
area=side*side*6;
return area;
}
@Override
double getvolum() {
double volum=0;
volum=side*side*side;
return volum;
}
}
class RegularPyramid extends Solid{
double side;
public RegularPyramid(double side) {
this.side = side;
}
@Override
double getarea() {
double baseArea = (Math.sqrt(3) / 4) * side * side;
double lateralArea = 3 * baseArea; // 正三棱锥有三个等边三角形的侧面
return baseArea + lateralArea;
}
@Override
double getvolum() {
return (Math.sqrt(2) / 12) * side * side * side ;
}
}
abstract class RubikCube extends Solid{
String color;
int layer;
Solid solid;
public RubikCube(String color, int layer, Solid solid) {
this.color = color;
this.layer = layer;
this.solid = solid;
}
abstract double getarea();
abstract double getvolum();
// 获取魔方颜色
public String getColor() {
return color;
}
}
class SquareCube extends RubikCube{
public SquareCube(String color, int layer, Solid solid) {
super(color, layer, solid);
}
@Override
double getarea() {
return layer * layer * solid.getarea();
}
@Override
double getvolum() {
return layer * layer * layer * solid.getvolum();
}
}
class RegularPyramidCube extends RubikCube{
public RegularPyramidCube(String color, int layer, Solid solid) {
super(color, layer, solid);
}
@Override
double getarea() {
return layer * layer * solid.getarea();
}
@Override
double getvolum() {
return layer * layer*layer * solid.getvolum();
}
}
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.Scanner;
import java.util.ArrayList;
import java.util.Comparator;
abstract class Solid{
double side;
abstract double getArea();
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 SquareCube extends RubikCube {
public SquareCube(String color, int layer, Solid solid) {
super(color, layer, solid);
}
@Override
public double getArea() {
return layer * layer * solid.getArea();
}
@Override
public double getVolume() {
return layer * layer * layer * solid.getVolume();
}
}
class RegularPyramid extends Solid {
private double side;
public RegularPyramid(double side) {
this.side = side;
}
@Override
public double getArea() {
double baseArea = (Math.sqrt(3) / 4) * side * side;
double lateralArea = 3 * baseArea; // 正三棱锥有三个等边三角形的侧面
return baseArea + lateralArea;
}
@Override
public double getVolume() {
return (Math.sqrt(2) / 12) * side * side * side ;
}
}
class RegularPyramidCube extends RubikCube {
public RegularPyramidCube(String color, int layer, Solid solid) {
super(color, layer, solid);
}
@Override
public double getArea() {
return layer * layer * solid.getArea();
}
@Override
public double getVolume() {
return layer * layer*layer * solid.getVolume();
}
}
abstract class RubikCube implements Comparable<RubikCube> {
String color;
int layer;
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 int getLayer() {
return layer;
}
public abstract double getArea() ;
public abstract double getVolume() ;
@Override
public int compareTo(RubikCube o) {
return ((int)this.getVolume()*100 - (int)o.getVolume()*100);
}
}
public class Main {
public static void main(String[] args) {
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("");
}
}
}//有一个测试点过不去。
三、总结
这几次的大作业让我受益很深，而期末考试又让我发现了我最大的不足之处，通过这几次的大作业，我对Java“一切皆类，面向对象”的特点有了更深层次的理解，懂得如何创建类与对象同时，学会了自己定义一些接口，我也明白了合理利用网络资源自学的重要性。值得一提的是，我发现学习面向对象语言时，我们必须要沉下心来，要学会思考，就算有的问题思考几个小时都可能解决不了，但只要你一直去思考并不断尝试就总是会想到解决方法，因为java中有很多类是可以更加方便地帮助我们解决问题，我们需要耐心的去寻找这类资源并学习，不能一味求快，急于求成，否则这样会事半功倍，严重可能会打消我们学习积极性。然后就是，经过这次的期末考试，我发现我学的并不扎实，还有好多地方存在不足，未来我还需要加倍努力，对不足之处加以弥补。
标签：layer,String,double,PTA,public,期末考试,PTA7,成绩,side From： https://www.cnblogs.com/ll77-blog/p/17881081.html