第三次博客作业
前言
经过一个学期的学习，终于结束了面向对象程序设计这门课程。这次博客主要总结一下最后的几次pta作业以及期末考试。
第七次大作业：这次的大作业题目一共有四道题，题量并不算大，主要的知识点一个是HashMap的运用，另一个就是课程统计程序的迭代。HashMap相对于课程统计程序来说不是特别难，但是课程统计程序的迭代难度相较于上一次难度就直线上升。
第八次大作业：这次作业的核心也是课程统计程序的迭代，其他的一对比就显得容易许多。
期末考试：期末考试的题目难度较小，主要还是涉及到多态和继承的关系，但是在小题目上我的失分比较多，说明我对一些概念理解的还不是很透彻。
设计与分析
第七次大作业
输入多个学生的成绩信息，包括：学号、姓名、成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
使用HashMap存储学生信息，并实现根据学号的检索功能
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩
以“end”为输入结束标志
end之后输入某个学号，执行程序输出该生的详细信息
输出格式:
输出查询到的学生信息格式：学号+英文空格+姓名+英文空格+成绩
如果没有查询到，则输出："The student "+查询的学号+" does not exist"
代码如下：
import java.util.HashMap; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input=new Scanner(System.in); HashMap<String,String > student=new HashMap<>(); while(true){ String mess1=input.nextLine(); if(mess1.equals("end")){ break; } String[] mess2=mess1.split(" "); student.put(mess2[0],mess2[1]+" "+mess2[2]); } String SearchID=input.nextLine(); String Searchresult=student.get(SearchID); if(Searchresult==null){ System.out.println("The student "+SearchID+" does not exist"); }else{ System.out.println(SearchID+" "+Searchresult); } } }
这道题目比较简单，只要掌握了HashMap的基本使用方法就基本不会出错，在这里就不做过多的阐述。
课程成绩统计程序-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.Comparator; import java.util.Scanner; import java.util.ArrayList; import java.util.Collections; public class Main{ public static void main(String[] args){ Scanner s=new Scanner(System.in); String s_record=s.nextLine(); ParseInput handle=new ParseInput(); while(!s_record.equals("end")){ handle.parseInput(s_record); s_record=s.nextLine(); } handle.showStudents(); handle.showCourses(); handle.showClasses(); } } class Cls implements Comparable<Cls>{ String Id; ArrayList<Student> listStudent=new ArrayList<>(); public ArrayList<Student> getListStudent() { return listStudent; } public String getId() { return Id; } void addStudent(Student stu){ listStudent.add(stu); } public void setId(String Id) { this.Id = Id; } public Cls(String Id){ this.Id=Id; } @Override public int compareTo(Cls o){ return Id.compareTo(o.getId()); } } class Student implements Comparable<Student>{ String Id; Cls cls; String name; public Student(String name,String Id){ this.name=name; this.Id=Id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Cls getCls() { return cls; } public void setCls(Cls cls) { this.cls = cls; } public String getId() { return Id; } public void setId(String Id) { this.Id = Id; } @Override public int compareTo(Student o){ return getId().compareTo(o.getId()); } } class ParseInput{ ArrayList<Course> listCourse=new ArrayList<>(); ArrayList<Student> listStudent=new ArrayList<>(); ArrayList<ChooseCourse> listChooseCourse=new ArrayList<>(); ArrayList<Cls> listCls=new ArrayList<>(); public void parseInput(String s){ int i=InputMatching.matchingInput(s); String[] items=s.split(" "); if(i == 0){ System.out.println("wrong format"); return; } else if(i == 1){ parseCourseRecord(items); return; } else if(i == 2){ parseScoreRecord(items); return; } } Course getCourse(String courseName){ for (int i=0;i<listCourse.size();i++) { if(listCourse.get(i).getName().equals(courseName)) return listCourse.get(i); } return null; } Cls getCls(String clsId){ for(int i=0;i<listCls.size();i++){ if(listCls.get(i).getId().equals(clsId)) return listCls.get(i); } return null; } Student getStudent(String stuId){ for(int i=0;i<listStudent.size();i++) { if(listStudent.get(i).getId().equals(stuId)) { return listStudent.get(i); } } return null; } private void parseCourseRecord(String[] items){ String courseName=items[0]; String courseType=items[1]; String checkType=items[2]; Course course=new Course(courseName,courseType,checkType); if(!checkCourse(course)) return; if(getCourse(courseName)==null){ course=new Course(courseName,courseType,checkType); listCourse.add(course); } } boolean checkCourse(Course course){ int courseTp,accessTp; if(course.getType().equals("必修")){ courseTp = 0; } else if(course.getType().equals("选修")){ courseTp = 1; } else { courseTp = -1; } if(course.getMethod().equals("考试")){ accessTp = 0; } else if(course.getMethod().equals("考察")){ accessTp = 1; } else { accessTp = -1; } if(courseTp==0&&(accessTp==0)) return true; if(courseTp==1&&(accessTp==0||accessTp==1)) return true; System.out.println(course.getName()+" : course type & access mode mismatch"); return false; } private void parseScoreRecord(String[] items){ String stuId=items[0]; String stuName=items[1]; String courseName=items[2]; String clsId=stuId.substring(0,6); Cls cls; Student stu; cls=getCls(clsId); if(cls==null){ cls=new Cls(clsId); listCls.add(cls); } stu=getStudent(stuId); if(stu==null){ stu=new Student(stuName,stuId); listStudent.add(stu); cls.addStudent(stu); } stu.setCls(cls); Course course=getCourse(courseName); if(course==null){ System.out.println(courseName+" does not exist"); return; } if(!checkGrade(items,course)) return; Grade grade; if(items.length==4){ int finalScore=Integer.parseInt(items[3]); grade=new AssessmentGrade(finalScore); }else { int usualScore=Integer.parseInt(items[3]); int finalScore=Integer.parseInt(items[4]); grade=new ExaminationGrade(usualScore,finalScore); } if(existChooseCourse(stu,course)) return; ChooseCourse chooseCourse=new ChooseCourse(course,stu,grade); listChooseCourse.add(chooseCourse); } boolean existChooseCourse(Student stu,Course course){ for(int i=0;i<listChooseCourse.size();i++){ if(listChooseCourse.get(i).getCourse().getName().equals(course.getName())) { if (listChooseCourse.get(i).getStudent().getName().equals(stu.getName())) return true; } } return false; } private boolean checkGrade(String[] items,Course course){ String courseType=course.getMethod(); if(courseType.equals("考试")&&items.length==5){ return true; } if(courseType.equals("考察")&&items.length==4){ return true; } System.out.println(items[0]+" "+items[1]+" : access mode mismatch"); return false; } public void showStudents(){ Collections.sort(listStudent); for(int i =0;i<listStudent.size();i++) { Student stu=listStudent.get(i); ArrayList<ChooseCourse> stuCourseSelects =getStudentSelects(stu.getId()); if(stuCourseSelects.size()!=0) { System.out.println(stu.getId() + " "+ stu.getName()+" "+getAvgTotalScore(stuCourseSelects)); } else { System.out.println(stu.getId() +" "+ stu.getName()+" did not take any exams"); } } } public void showCourses(){ Collections.sort(listCourse); for(int i =0;i<listCourse.size();i++) { Course course = listCourse.get(i); ArrayList<ChooseCourse> courseSelects = getCourseSelects(course.getName()); if(courseSelects.size()== 0) { System.out.println(course.getName() + " has no grades yet"); } else { if(course.getMethod().equals("考试")) { System.out.println(course.getName() + " " +getAvgUsualScore(courseSelects)+ " "+getAvgFinalScore(courseSelects)+ " "+getAvgTotalScore(courseSelects)); }else{ System.out.println(course.getName() + " "+getAvgFinalScore(courseSelects)+ " "+getAvgTotalScore(courseSelects)); } } } } public void showClasses(){ Collections.sort(listCls); for(int i =0;i<listCls.size();i++) { Cls cls = listCls.get(i); ArrayList<ChooseCourse> classCourseSelects = getClassSelects(cls.getId()); if(classCourseSelects.size()==0){ System.out.println(cls.getId()+" has no grades yet"); } else{ System.out.println(cls.getId()+" "+ getAvgTotalScore(classCourseSelects)); } } } public static int getAvgUsualScore(ArrayList<ChooseCourse> courseSelects) { int sum = 0; for(ChooseCourse cs : courseSelects) { sum +=((ExaminationGrade) cs.grade).getUsualScore(); } return sum/courseSelects.size(); } public int getAvgTotalScore(ArrayList<ChooseCourse> listChooseCourse) { int sum =0; for(ChooseCourse cs : listChooseCourse) { sum +=cs.grade.getTotalScore(); } return sum/listChooseCourse.size(); } public int getAvgFinalScore(ArrayList<ChooseCourse> courseSelects) { int sum =0; for(ChooseCourse cs : courseSelects) { sum +=cs.grade.getFinalScore(); } return sum/courseSelects.size(); } public ArrayList<ChooseCourse> getClassSelects(String className){ Cls cls=getCls(className); ArrayList<ChooseCourse> classSelects = new ArrayList<>(); for (ChooseCourse cs : listChooseCourse) { if (className.equals(cs.getStudent().cls.getId())){ classSelects.add(cs); } } return classSelects; } public ArrayList<ChooseCourse> getStudentSelects(String stuId) { ArrayList<ChooseCourse> stuSelects = new ArrayList<>(); for (ChooseCourse cs : listChooseCourse) { if (stuId.equals(cs.student.getId())){ stuSelects.add(cs); } } return stuSelects; } public ArrayList<ChooseCourse> getCourseSelects(String courseName){ ArrayList<ChooseCourse> courseSelect=new ArrayList<>(); for (ChooseCourse cs : listChooseCourse) { if (courseName.equals(cs.course.getName())){ courseSelect.add(cs); } } return courseSelect; } } class ChooseCourse{ Course course; Student student; Grade grade; public ChooseCourse(Course course, Student student, Grade grade) { this.course=course; this.grade=grade; this.student=student; } public Grade getGrade() { return grade; } public Student getStudent() { return student; } public Course getCourse() { return course; } } class InputMatching { static String stuNumMatching = "\\d{8}"; static String stuNameMatching = "[^ \\t]{1,10}"; static String scoreMatching = "([1-9]?[0-9]|100)"; static String courseNameMatching = "[^ \\t]{1,10}"; static String courseTypeMatching = "(选修|必修)"; static String checkcourseTypeMatching = "(考试|考察)"; static String scoreMatching1 = "(\\s([1-9]?[0-9]|100))?"; static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching; static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " + scoreMatching + scoreMatching1; public static int matchingInput(String s) { if (matchingCourse(s)) { return 1; } if (matchingScore(s)) { return 2; } return 0; } private static boolean matchingCourse(String s) { return s.matches(courseInput); } private static boolean matchingScore(String s) { return s.matches(scoreInput); } } class Course implements Comparable<Course>{ String name; String type; String method; public String getMethod() { return method; } public void setMethod(String method) { this.method = method; } public String getType() { return type; } public void setType(String type) { this.type = type; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Course(String name,String type){ this.type = type; this.name = name; } public Course(String name,String type,String method){ this.name=name; this.type=type; this.method=method; } @Override public int compareTo(Course o){ Comparator<Object> compare=Collator.getInstance(java.util.Locale.CHINA); return compare.compare(name,o.getName()); } } abstract class Grade{ protected int finalScore; protected int totalScore; public int getTotalScore() { return totalScore; } public int getFinalScore() { return finalScore; } Grade(int finalScore){this.finalScore=finalScore;} } class ExaminationGrade extends Grade{ private int usualScore; public int getUsualScore() { return usualScore; } ExaminationGrade(int usualScore, int finalScore){ super(finalScore); this.usualScore=usualScore; this.totalScore=(int)(finalScore*0.7+usualScore*0.3); } } class AssessmentGrade extends Grade{ AssessmentGrade(int finalScore){ super(finalScore); this.totalScore=finalScore; } }
设计类图如下：
第八次大作业
题目描述
编辑
输入多个学生的成绩信息，包括：学号、姓名、数学成绩、物理成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
要求：使用ArrayList存储学生信息。
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+数学成绩+英文空格+物理成绩
以“end”为输入结束标志
输出格式:
按数学/物理成绩之和从高到低的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+数学/物理成绩之和
成绩相同的情况，按输入的先后顺序输出。
import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.Scanner; class Student { private String id; private String name; private int Score1; private int Score2; public Student(String id, String name, int Score1, int Score2) { this.id = id; this.name = name; this.Score1 = Score1; this.Score2 = Score2; } public int getTotalScore() { return Score1 + Score2; } public String toString() { return id + " " + name + " " + getTotalScore(); } } class Main { public static void main(String[] args) { List<Student> studentList = new ArrayList<>(); Scanner scanner = new Scanner(System.in); while (true) { String input = scanner.nextLine(); if (input.equals("end")) { break; } String[] str = input.split(" "); String id = str[0]; String name = str[1]; int physicsScore = Integer.parseInt(str[3]); int mathScore = Integer.parseInt(str[2]); Student student = new Student(id, name, mathScore, physicsScore); studentList.add(student); } Collections.sort(studentList, Comparator.comparing(Student::getTotalScore).reversed()); for (Student student : studentList) { System.out.println(student); } } }
知识点：
一.ArrayList：ArrayList 类继承了 AbstractList 并实现了 List 接口。 ArrayList 支持可以根据需要增长的动态数组。
ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下：
import java.util.ArrayList; // 引入 ArrayList 类
ArrayList<E> objectName =new ArrayList<E>(); // 初始化
- E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。
- objectName: 对象名
-
添加元素： 使用add()方法将元素添加到ArrayList
-
删除元素： 使用remove()方法将元素从ArrayList中删除
计算ArrayList大小： 使用size()方法计算ArrayList大小
-
查询ArrayList中特定元素： 使用contains()方法ArrayList中是否有某个元素
-
查询ArrayList中特定元素的位置： 使用indexOf()方法查询ArrayList中某个元素的位置
-
判断集合是否为空： 使用isEmpty()方法判断集合是否为空
ArrayList与一般数组的区别
- 一般数组在创建时就必须确定大小：
但是对于ArrayList，你只需要创建出此类型的对象即可。它不需要指定大小，因为它会在加入或删除元素时自动调整大小
2.存放对象给一般数组时，必须指定位置
必须要指定在0到比length小1之间的数字，如果索引值超越了数组的限制（例如数组声明为2，但是指定的数字是3），就会报错。
使用ArrayList时，可以用add(Int, Object)形式的方法来指定索引值，或使用add(Object)形式的方法让它自行管理大小。
课程成绩统计程序-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"
这次课程统计程序的迭代相较于2来说难度增加了许多，由于时间的关系，这道题没有做出来
期末考试
编程求得正方体和正三棱锥的表面积和体积，要求必须体现扩展性（继承）和多态性。
类结构如下图所示（参考）：
试编程完成如上类设计，主方法源码如下（可直接拷贝使用）：
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())); } } class Cube extends Solid{ Cube(double side){ this.side = side; } public double getArea() { return side*side*6; } public double getVolume() { return side*side*side; } } class RegularPyramid extends Solid{ RegularPyramid(){ } RegularPyramid(double side){ this.side = side; } public double getArea() { return side*side*Math.sqrt(3); } public double getVolume() { return Math.sqrt(6)*side*Math.sqrt(3) * side * side / 36; } } abstract class Solid { protected double side; Solid(){ } Solid(double side) { this.side = side; } void setside(double side) { this.side = side; } double getside() { return side; } double getArea() { return side; } double getVolume() { return side; } }
问题描述：本问题中的魔方有两种，一种是正方体魔方，一种是正三棱锥魔方，其中，正方体或正三棱锥魔方是由单元正方体或正三棱锥组成，单元正方体或正三棱锥的个数由阶数（即层数）决定，
即魔方边长=阶数*单元边长。魔方如下图所示：
利用“立体图形”问题源码，实现如下功能：
魔方有三个属性：颜色，阶数，类型（正方体魔方、正三棱锥魔方），程序要求输出魔方的颜色、表面积和体积。参考设计类图如下所示：
主方法部分可参考如下源码（可拷贝直接使用）：
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) { // TODO Auto-generated method stub Scanner input = new Scanner(System.in); String color = input.next(); int layer = input.nextInt(); double side = input.nextDouble(); Cube cube = new Cube(color,layer,side); double Area1 = cube.getArea(); double Volume1 = cube.getVolume(); System.out.println(color); System.out.println(String.format("%.2f", Area1)); System.out.println(String.format("%.2f", Volume1)); color = input.next(); layer = input.nextInt(); side = input.nextDouble(); RegularPyramid regularPyramid = new RegularPyramid(color,layer,side); double Area2 = regularPyramid.getArea(); double Volume2 = regularPyramid.getVolume(); System.out.println(color); System.out.println(String.format("%.2f", Area2)); System.out.println(String.format("%.2f", Volume2)); } } class Cube{ String color; int layer; double side; public Cube(String color,int layer,double side) { this.color = color; this.layer = layer; this.side = side; } public double getArea() { return side*layer*side*layer*6; } public double getVolume() { return side*side*side*layer*layer*layer; } public String getColor() { return color; } } class RegularPyramid{ String color; int layer; double side; public RegularPyramid(String color,int layer,double side) { this.color = color; this.layer = layer; this.side = side; } public double getArea() { return side*layer*side*layer*Math.sqrt(3); } public double getVolume() { return Math.sqrt(6)*(side*layer)*Math.sqrt(3) * (side*layer)* (side*layer) / 36; } public String getColor() { return color; } }
期末考试的几道编程题都比较简单，主要就是接口和继承关系的运用，对我来说比较难的是选择题一些小题的错误比较多。
踩坑心得
这几次的作业主要难度是两个课程统计程序的迭代，课程统计里面的情况比较复杂，需要考虑的情况也比较多，需要提前设计好类图，这样才能在真正编写代码的做到有条不紊，才能在实现功能的时候不会漏考虑一些情况。
总结
经过一段时间的学习，我对于Java这门编程语言有了更深入的理解和掌握。这门课程让我了解了Java的基本语法、面向对象的编程思想、数据结构和算法、以及Java在开发中的应用。通过学习，我不仅掌握了Java的基础知识，还学会了如何使用Java进行实际开发。
在学习过程中，我遇到了一些困难和挑战。例如，对于Java的异常处理机制，我最初有些困惑。但是，通过不断地实践和理解，我逐渐明白了异常处理的重要性以及如何正确地使用它。此外，对于Java的集合框架和多线程编程，我花费了较多的时间来学习和练习。但是，通过这些努力，我能够更好地理解和使用这些重要概念。在学习过程中，我自己意识到对于这门语言的学习仅用一个学期是远远不够的，还需要在以后的学习生涯中不断精进自己的知识，才能对这门语言有更加深刻的理解。
总的来说，这门课程让我受益匪浅。我不仅掌握了Java的基础知识，还学会了如何使用Java进行实际开发。同时，这门课程还让我了解了Java在现实世界中的应用和未来的发展方向。我相信，通过这门课程的学习，我将更好地适应未来的工作和发展。
