南昌航空大学第三次BLOG
南航航空大学第三次BLOG
前言
本次博客主要涵盖了Java题目的几个主要知识点，包括面向对象编程（Object-Oriented Programming, OOP）、类与对象、构造方法、访问权限、成员变量、继承和组合、异常处理、字符串处理以及控制流和数据结构。
在面向对象编程中，类是创建对象的蓝图或模板，而对象则是类的实例。构造方法用于在创建对象时初始化对象。访问权限修饰符决定了类、变量、方法和构造器的可访问性，包括private、protected、public和默认（不使用任何修饰符，也称为包私有级别）。
成员变量是类中定义的变量，根据其访问权限，可以被对象自身的方法、类中其他方法或外部方法访问。继承和组合是实现代码复用的两种方式，其中继承通过扩展现有的类来创建新类，而组合通过将其他对象的引用包含在当前对象中来实现代码复用。
异常处理是保证程序健壮性的重要环节，Java提供了try-catch-finally块来捕获和处理异常。字符串处理是通过String类实现的，提供了丰富的方法来进行字符串的操作，如拼接、分割、替换等。
控制流包括循环和条件语句，用于实现逻辑控制。数据结构如数组、列表、集合和映射等在Java中起着重要的作用，提供了存储和管理数据的方式，对于实现算法和功能逻辑至关重要。
综上所述，本次题目涵盖了面向对象编程的基本概念、构造方法和访问权限的使用、成员变量的定义与访问、继承和组合的原则、异常处理机制、字符串处理技巧以及控制流和数据结构的应用。这些知识点对于编写高效、可靠和可维护的Java程序至关重要。整体难度属于中等偏上，适合用来考察学生对面向对象设计原则和异常处理的理解。题目数量适中，涵盖了多个细节和需求，包括各种异常处理和特殊情况的处理。
设计与分析
1.课程成绩统计程序-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.*;
public class Main {
public static void main(String[] args) {
HashMap<String, Course> courses = new HashMap<>();
HashMap<String, Student> students = new HashMap<>();
HashMap<String, StudentClass> classes = new HashMap<>();
ArrayList<ChooseCourse> chooseCourses = new ArrayList<>();
Scanner input = new Scanner(System.in);
String sentence = input.nextLine();
while (!sentence.equals("end")) {
if (sentence.matches("^\\S{1,10} (必修|选修|实验) (考试|考察|实验)$")) {
String[] splited = sentence.split(" ");
if (((splited[1].equals("必修") && splited[2].equals("考试")) ||
(splited[1].equals("选修") && (splited[2].equals("考试") || splited[2].equals("考察")))) ||
(splited[1].equals("实验") && splited[2].equals("实验"))) {
if (!courses.containsKey(splited[0])) {
Course course = new Course();
course.name = splited[0];
course.category = splited[1];
course.method = splited[2];
courses.put(splited[0], course);
}
} else {
System.out.println(splited[0] + " : course type & access mode mismatch");
}
} else if (sentence.matches("[0-9]{8} \\S{1,10} \\S{1,10} ([0-9]|[1-9][0-9]|100)")) {
String[] splited = sentence.split(" ");
String studentNum = splited[0];
String studentName = splited[1];
String courseName = splited[2];
int grade = Integer.parseInt(splited[3]);
if (!students.containsKey(studentNum)) {
Student student = new Student();
student.num = studentNum;
student.name = studentName;
students.put(studentNum, student);
}
Student student = students.get(studentNum);
if (!classes.containsKey(studentNum.substring(0, 6))) {
StudentClass studentClass = new StudentClass();
studentClass.classNum = studentNum.substring(0, 6);
studentClass.students = new HashMap<>();
classes.put(studentNum.substring(0, 6), studentClass);
}
classes.get(studentNum.substring(0, 6)).students.put(studentNum, student);
if (!courses.containsKey(courseName)) {
System.out.println(studentNum + " does not exist");
break;
} else {
Course course = courses.get(courseName);
if (course.method.equals("考察")) {
if (course.category.equals("必修")) {
System.out.println(studentNum + " " + studentName + " : access mode mismatch");
break;
}
ChooseCourse chooseCourse = new ChooseCourse();
chooseCourse.student = student;
chooseCourse.course = course;
CheckScore checkScore = new CheckScore();
checkScore.finalGrade = grade;
chooseCourse.score = checkScore;
chooseCourses.add(chooseCourse);
} else if (course.method.equals("考试")) {
if (course.category.equals("实验")) {
System.out.println(studentNum + " " + studentName + " : access mode mismatch");
break;
}
ChooseCourse chooseCourse = new ChooseCourse();
chooseCourse.student = student;
chooseCourse.course = course;
TestScore testScore = new TestScore();
testScore.finalGrade = grade;
chooseCourse.score = testScore;
chooseCourses.add(chooseCourse);
}
}
} else if (sentence.matches("[0-9]{8} \\S{1,10} \\S{1,10} ([0-9]|[1-9][0-9]|100) ([0-9]|[1-9][0-9]|100)")) {
String[] splited = sentence.split(" ");
String studentNum = splited[0];
String studentName = splited[1];
String courseName = splited[2];
int dailyGrade = Integer.parseInt(splited[3]);
int finalGrade = Integer.parseInt(splited[4]);
if (!students.containsKey(studentNum)) {
Student student = new Student();
student.num = studentNum;
student.name = studentName;
students.put(studentNum, student);
}
Student student = students.get(studentNum);
if (!classes.containsKey(studentNum.substring(0, 6))) {
StudentClass studentClass = new StudentClass();
studentClass.classNum = studentNum.substring(0, 6);
studentClass.students = new HashMap<>();
classes.put(studentNum.substring(0, 6), studentClass);
}
classes.get(studentNum.substring(0, 6)).students.put(studentNum, student);
if (!courses.containsKey(courseName)) {
System.out.println(studentNum + " does not exist");
break;
} else {
Course course = courses.get(courseName);
if (course.method.equals("考察")) {
System.out.println(studentNum + " " + studentName + " : access mode mismatch");
break;
} else if (course.method.equals("考试")) {
ChooseCourse chooseCourse = new ChooseCourse();
chooseCourse.student = student;
chooseCourse.course = course;
TestScore testScore = new TestScore();
testScore.dialyGrade = dailyGrade;
testScore.finalGrade = finalGrade;
chooseCourse.score = testScore;
chooseCourses.add(chooseCourse);
}
}
} else if (sentence.matches("([0-9]{8})( )(\\S{1,10})( )(\\S{1,10})( )([4-9])( )((([0-9]|[1-9][0-9]|100)( ))+)([0-9]|[1-9][0-9]|100)")) {
String[] splited = sentence.split(" ");
String studentNum = splited[0];
String studentName = splited[1];
String courseName = splited[2];
int numExperiments = Integer.parseInt(splited[3]);
List<Integer> grades = new ArrayList<>();
for (int i = 4; i < splited.length; i++) {
grades.add(Integer.parseInt(splited[i]));
}
if (!students.containsKey(studentNum)) {
Student student = new Student();
student.num = studentNum;
student.name = studentName;
students.put(studentNum, student);
}
Student student = students.get(studentNum);
if (!classes.containsKey(studentNum.substring(0, 6))) {
StudentClass studentClass = new StudentClass();
studentClass.classNum = studentNum.substring(0, 6);
studentClass.students = new HashMap<>();
classes.put(studentNum.substring(0, 6), studentClass);
}
classes.get(studentNum.substring(0, 6)).students.put(studentNum, student);
if (!courses.containsKey(courseName)) {
System.out.println(studentNum + " does not exist");
break;
} else {
Course course = courses.get(courseName);
if (!course.method.equals("实验")) {
System.out.println(studentNum + " " + studentName + " : access mode mismatch");
break;
} else if (numExperiments != grades.size()) {
System.out.println(studentNum + " " + studentName + " : access mode mismatch");
break;
} else {
ChooseCourse chooseCourse = new ChooseCourse();
chooseCourse.student = student;
chooseCourse.course = course;
ExperimentScore experimentScore = new ExperimentScore();
experimentScore.grades = grades;
chooseCourse.score = experimentScore;
chooseCourses.add(chooseCourse);
}
}
} else {
System.out.println("wrong format");
}
sentence = input.nextLine();
}
// 按照学号排序，并输出成绩
TreeMap<String, Student> sortedMap = new TreeMap<>(students);
for (Student student : sortedMap.values()) {
String num = student.num;
String name = student.name;
int allGrade = 0;
int addNum = 0;
for (ChooseCourse chooseCourse : chooseCourses) {
if (num.equals(chooseCourse.student.num)) {
allGrade += chooseCourse.score.getGrade();
addNum++;
}
}
if (addNum == 0) {
System.out.println(num + " " + name + " did not take any exams");
} else {
int averageGrade = allGrade / addNum;
System.out.println(num + " " + name + " " + averageGrade);
}
}
// 给课程排序
Comparator<String> chineseComparator = (s1, s2) -> {
Collator collator = Collator.getInstance(Locale.CHINA);
return collator.compare(s1, s2);
};
List<String> sortedKeys = new ArrayList<>(courses.keySet());
sortedKeys.sort(chineseComparator);
for (String key : sortedKeys) {
Course course = courses.get(key);
int addNum = 0;
int allGrade = 0;
int finalGrade = 0;
int dailyGrade = 0;
int addNum1 = 0;
int x = -1;
for (ChooseCourse chooseCourse : chooseCourses) {
if (key.equals(chooseCourse.course.name)) {
if (course.category.equals("必修")) {
x = 0;
allGrade += chooseCourse.score.getGrade();
if (chooseCourse.score instanceof TestScore) {
finalGrade += ((TestScore) chooseCourse.score).finalGrade;
dailyGrade += ((TestScore) chooseCourse.score).dailyGrade;
addNum++;
addNum1++;
}
}
if (course.category.equals("选修")) {
allGrade += chooseCourse.score.getGrade();
if (chooseCourse.course.method.equals("考试")) {
x = 0;
if (chooseCourse.score instanceof TestScore) {
finalGrade += ((TestScore) chooseCourse.score).finalGrade;
dailyGrade += ((TestScore) chooseCourse.score).dailyGrade;
addNum++;
addNum1++;
}
}
if (chooseCourse.course.method.equals("考察")) {
x = 2;
finalGrade += chooseCourse.score.getGrade();
addNum++;
}
}
if (chooseCourse.course.method.equals("实验")) {
x = 1;
allGrade += chooseCourse.score.getGrade();
addNum++;
}
}
}
if (x == -1) {
System.out.println(course.name + " has no grades yet");
} else if (x == 0) {
System.out.println(key + " " + dailyGrade / addNum1 + " " + finalGrade / addNum + " " + allGrade / addNum);
} else if (x == 2) {
System.out.println(key + " " + finalGrade / addNum + " " + allGrade / addNum);
} else {
System.out.println(key + " " + allGrade / addNum);
}
}
// 给班级排序
TreeMap<String, StudentClass> sortedClassMap = new TreeMap<>(classes);
for (StudentClass studentClass : sortedClassMap.values()) {
String classNum = studentClass.classNum;
int allGrade = 0;
int addNum = 0;
for (Student student : studentClass.students.values()) {
String studentNum = student.num;
for (ChooseCourse chooseCourse : chooseCourses) {
if (studentNum.equals(chooseCourse.student.num)) {
allGrade += chooseCourse.score.getGrade();
addNum++;
}
}
}
if (addNum == 0) {
System.out.println(classNum + " has no grades yet");
} else {
int averageGrade = allGrade / addNum;
System.out.println(classNum + " " + averageGrade);
}
}
}
}
class Student {
String num;
String name;
}
class StudentClass {
String classNum;
HashMap<String, Student> students;
}
class Course {
String name;
String category;
String method;
}
abstract class Score {
abstract int getGrade();
}
class TestScore extends Score {
public int dialyGrade;
int finalGrade;
int dailyGrade;
@Override
int getGrade() {
return (int) (finalGrade * 0.7 + dailyGrade * 0.3);
}
}
class CheckScore extends Score {
int finalGrade;
@Override
int getGrade() {
return finalGrade;
}
}
class ExperimentScore extends Score {
List<Integer> grades;
@Override
int getGrade() {
int sum = 0;
for (int grade : grades) {
sum += grade;
}
return sum / grades.size();
}
}
class ChooseCourse {
Student student;
Course course;
Score score;
}
2.课程成绩统计程序-3
题目要求
课程成绩统计程序-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）成绩平均分只取整数部分，小数部分丢弃
参考类图（与第一次相同，其余内容自行补充）：
因为伤病的原因我并未完成这最后一次的大题。
3.期末考试
7-1 立体图形问题
编程求得正方体和正三棱锥的表面积和体积，要求必须体现扩展性（继承）和多态性。
类结构如下图所示（参考）：
试编程完成如上类设计，主方法源码如下（可直接拷贝使用）：
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;
// 抽象类 Solid，表示立体
abstract class Solid {
protected double side; // 边长
public Solid(double side) {
this.side = side;
}
public abstract double surfaceArea();
public abstract double volume();
}
// 正方体类，继承自立体类
class Cube extends Solid {
public Cube(double side) {
super(side);
}
@Override
public double surfaceArea() {
return 6 * side * side;
}
@Override
public double volume() {
return side * side * side;
}
}
// 正三棱锥类，继承自立体类
class RegularPyramid extends Solid {
public RegularPyramid(double side) {
super(side);
}
@Override
public double surfaceArea() {
double slantHeight = Math.sqrt(side * side * 3.0 / 4.0);
return 4.0 * side * slantHeight / 2.0;
}
@Override
public double volume() {
double slantHeight = Math.sqrt(side * side * 3.0 / 4.0);
return (side * Math.sqrt(2.0 / 3.0)) * side * slantHeight / 2.0 / 3.0;
}
}
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double side = input.nextDouble(); // 输入边长
display(new Cube(side)); // 调用 display 方法，传入 Cube 对象
display(new RegularPyramid(side)); // 调用 display 方法，传入 RegularPyramid 对象
}
// display 方法，体现多态性
public static void display(Solid solid) {
System.out.println( String.format("%.2f", solid.surfaceArea())); // 输出表面积
System.out.println( String.format("%.2f", solid.volume())); // 输出体积
}
}
利用“立体图形”问题源码，实现如下功能：
魔方有三个属性：颜色，阶数，类型（正方体魔方、正三棱锥魔方），程序要求输出魔方的颜色、表面积和体积。参考设计类图如下所示：
主方法部分可参考如下源码（可拷贝直接使用）：
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;
class Cube {
private double side;
public Cube(double side) {
this.side = side;
}
public double getSide() {
return side;
}
}
abstract class RubikCube {
protected String color;
protected int layer;
public RubikCube(String color, int layer) {
this.color = color;
this.layer = layer;
}
abstract double getSurfaceArea();
abstract double getVolume();
}
class SquareRubikCube extends RubikCube {
private final Cube cube;
public SquareRubikCube(String color, int layer, Cube cube) {
super(color, layer);
this.cube = cube;
}
double getSurfaceArea() {
double side = layer * cube.getSide();
return 6 * side * side;
}
double getVolume() {
double side = layer * cube.getSide();
return side * side * side;
}
}
class RegularPyramidRubikCube extends RubikCube {
private final RegularPyramid pyramid;
public RegularPyramidRubikCube(String color, int layer, RegularPyramid pyramid) {
super(color, layer);
this.pyramid = pyramid;
}
double getSurfaceArea() {
double side = layer * pyramid.getSide();
double height = layer * pyramid.getHeight();
return side * side * Math.sqrt(3) ;
}
double getVolume() {
double side = layer * pyramid.getSide();
double height = layer * pyramid.getHeight();
return (side * side * Math.sqrt(3) * height) / 12.0 ;
}
}
class RegularPyramid {
private double side;
private double height;
public RegularPyramid(double side) {
this.side = side;
this.height = side * Math.sqrt(2.0 / 3.0);
}
public double getSide() {
return side;
}
public double getHeight() {
return height;
}
public double getSurfaceArea() {
return 4 * getTriangleArea();
}
public double getVolume() {
return (getTriangleArea() * height) / 3.0;
}
private double getTriangleArea() {
return (side * side * Math.sqrt(3)) / 4.0;
}
}
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 SquareRubikCube(color, layer, new Cube(side));
color = input.next();
layer = input.nextInt();
side = input.nextDouble();
RubikCube cube2 = new RegularPyramidRubikCube(color, layer, new RegularPyramid(side));
display(cube1);
display(cube2);
}
public static void display(RubikCube cube) {
System.out.println(cube.color);
System.out.println(String.format("%.2f", cube.getSurfaceArea()));
System.out.println(String.format("%.2f", cube.getVolume()));
}
}
提示：题目中RubikCube类要实现Comparable接口。
其中，Main类源码如下（可直接拷贝使用）：
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
String color;
int layer;
double side;
RubikCube cube;
ArrayList<RubikCube> list = new ArrayList<>();
int choice = input.nextInt();
while(choice != 0) {
switch(choice) {
case 1://SquareCube
color = input.next();
layer = input.nextInt();
side = input.nextDouble();
cube = new SquareCube(color, layer,new Cube(side));
list.add(cube);
break;
case 2://RegularPyramidCube
color = input.next();
layer = input.nextInt();
side = input.nextDouble();
cube = new RegularPyramidCube(color, layer,new RegularPyramid(side));
list.add(cube);
break;
}
choice = input.nextInt();
}
list.sort(Comparator.naturalOrder());//正向排序
for(int i = 0; i < list.size(); i++) {
System.out.print(list.get(i).getColor() + " " +
String.format("%.2f", list.get(i).getArea()) + " " +
String.format("%.2f", list.get(i).getVolume()) );
System.out.println("");
}
}
}
输入格式:
输入魔方类型（1：正方体魔方；2：正三棱锥魔方；0：结束输入）
魔方颜色、魔方阶数、魔方单元正方体、正三棱锥边长
..循环..
输出格式:
按魔方体积升序输出列表中各魔方的信息（实型数均保留两位小数），输出样式参见输出样例。
输入样例:
在这里给出一组输入。例如：
1 blue 3 4.5
2 red 4 2.1
1 yellow 5 2.3
2 black 4 9.42
1 white 4 5.4423
0
输出样例:
在这里给出相应的输出。例如：
red 122.21 69.85
yellow 793.50 1520.88
blue 1093.50 2460.38
black 2459.14 6304.73
white 2843.39 10316.38
代码如下：
点击查看代码
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
class Cube {
private double side;
public Cube(double side) {
this.side = side;
}
public double getSide() {
return side;
}
}
abstract class RubikCube implements Comparable<RubikCube> {
protected String color;
protected int layer;
public RubikCube(String color, int layer) {
this.color = color;
this.layer = layer;
}
abstract double getSurfaceArea();
abstract double getVolume();
public String getColor() {
return color;
}
@Override
public int compareTo(RubikCube other) {
double volume1 = this.getVolume();
double volume2 = other.getVolume();
if (volume1 < volume2) {
return -1;
} else if (volume1 > volume2) {
return 1;
} else {
return 0;
}
}
}
class SquareCube extends RubikCube {
private final Cube cube;
public SquareCube(String color, int layer, Cube cube) {
super(color, layer);
this.cube = cube;
}
double getSurfaceArea() {
double side = layer * cube.getSide();
return 6 * side * side;
}
double getVolume() {
double side = layer * cube.getSide();
return side * side * side;
}
}
class RegularPyramidCube extends RubikCube {
private final RegularPyramid pyramid;
public RegularPyramidCube(String color, int layer, RegularPyramid pyramid) {
super(color, layer);
this.pyramid = pyramid;
}
double getSurfaceArea() {
double side = layer * pyramid.getSide();
double height = layer * pyramid.getHeight();
return side * side * Math.sqrt(3) ;
}
double getVolume() {
double side = layer * pyramid.getSide();
double height = layer * pyramid.getHeight();
return (side * side * Math.sqrt(3) * height) / 12.0 ;
}
}
class RegularPyramid {
private double side;
private double height;
public RegularPyramid(double side) {
this.side = side;
this.height = side * Math.sqrt(2.0 / 3.0);
}
public double getSide() {
return side;
}
public double getHeight() {
return height;
}
public double getSurfaceArea() {
return 4 * getTriangleArea();
}
public double getVolume() {
return (getTriangleArea() * height) / 3.0;
}
private double getTriangleArea() {
return (side * side * Math.sqrt(3)) / 4.0;
}
}
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).getSurfaceArea()) + " " +
String.format("%.2f", list.get(i).getVolume()));
System.out.println("");
}
}
}
不到（含）1000美元的部分为10%；
1000（含）~1800美元的部分为15%；
超过1800美元的部分为20%。
佣金程序生成月份销售报告，汇总销售商的销售总额和佣金。
编程要求：必须符合面向对象编程，且保证类设计的单一职责模式，使用面向过程编程判定0分。
提示：可以设置一个销售订单类。参考类图如下：
输入格式:
输入销售商每个月售出枪机、枪托、枪管的数量，可以用空格或者回车分隔。
输出格式:
分别输出销售商在该月的销售额和佣金，中间用空格分开。
输入样例1:
在这里给出一组输入。例如：
30 40 50
输出样例1:
在这里给出相应的输出。例如：
3800.00 620.00
输入样例2:
在这里给出一组输入。例如：
88 56 98
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
分析如下
本题要求设计符合面向对象编程的程序，实现销售订单的计算和佣金的计算。对于输入的数据，需要进行格式检查，并判断是否超过生产限额。输出销售总额和佣金。
在这个问题中，可以使用一个销售订单类来表示销售商的销售订单，并在其中实现计算销售额和佣金的方法。该类应该具有一个构造函数来初始化销售订单的属性（即销售的枪机、枪托和枪管数量）。然后，它应该有两个公共方法：一个是计算销售额的方法，另一个是计算佣金的方法。在计算佣金时，可以根据销售额的不同范围采用不同的佣金率。
总结一下，需要完成以下步骤：
创建一个销售订单类
在销售订单类中实现计算销售额的方法
在销售订单类中实现计算佣金的方法
检查输入的格式并判断是否超过生产限额
输出销售总额和佣金
由于时间问题未拿到满分
代码如下：
点击查看代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();
String[] sales = input.split(" ");
int gunCount = Integer.parseInt(sales[0]);
int stockCount = Integer.parseInt(sales[1]);
int barrelCount = Integer.parseInt(sales[2]);
GunSalesman salesman = new GunSalesman(gunCount, stockCount, barrelCount);
salesman.calculateSalesAmount();
salesman.calculateCommission();
System.out.printf("%.2f %.2f", salesman.getSalesAmount(), salesman.getCommission());
}
}
class GunSalesman {
private int gunCount;
private int stockCount;
private int barrelCount;
private double salesAmount;
private double commission;
public GunSalesman(int gunCount, int stockCount, int barrelCount) {
this.gunCount = gunCount;
this.stockCount = stockCount;
this.barrelCount = barrelCount;
}
public void calculateSalesAmount() {
salesAmount = gunCount * 45 + stockCount * 30 + barrelCount * 25;
}
public void calculateCommission() {
if (salesAmount <= 1000) {
commission = salesAmount * 0.1;
} else if (salesAmount <= 1800) {
commission = 1000 * 0.1 + (salesAmount - 1000) * 0.15;
} else {
commission = 1000 * 0.1 + 800 * 0.15 + (salesAmount - 1800) * 0.2;
}
}
public double getSalesAmount() {
return salesAmount;
}
public double getCommission() {
return commission;
}
}
踩坑心得
经过这一阶段的学习与实践，我总结出了如下的问题
-
代码应该具有良好的可读性和可维护性，同时也要注意代码复杂度，避免出现过于复杂的逻辑。
-
重视输入验证和异常处理，尽可能识别并处理所有可能出现的异常情况，并给出正确的错误提示。
-
选择合适的数据结构和算法，以实现高效的数据检索和计算。
-
在编写代码时，应该考虑到程序的性能，并进行必要的优化。
-
编写全面的测试用例，以确保程序的健壮性和正确性。
-
在编写代码时，应该遵循良好的编码规范和标准，以确保代码具有一致的风格和格式。
总的来说，编写高质量的程序需要综合考虑多个因素，包括可读性、可维护性、异常处理、数据结构和算法、测试覆盖率等。只有在这些方面都做到了好，才能编写出高效、健壮且易于维护的程序。、
改进建议 -
提高代码质量：在编写代码时，应该注重代码质量，尽可能遵循良好的编程规范和标准。这包括使用有意义的变量名、编写清晰的注释和文档、避免重复代码等。
-
优化性能：如果程序处理大量数据，可以考虑对算法进行优化，或使用高效的数据结构。此外，还可以使用并行计算等技术来提高程序的性能。
-
异常处理：加强对异常情况的处理，避免程序崩溃或出现未处理的错误。同时，可以通过记录日志的方式来方便排查问题。
-
测试覆盖率：编写全面的测试用例，覆盖所有可能的情况，并通过自动化测试来确保程序的正确性和健壮性。
-
优化算法和数据结构：根据具体需求，选择合适的算法和数据结构，以提高程序的效率和性能。
-
模块化和函数抽象：通过模块化和函数抽象来减少代码复杂度，提高代码的可读性和可维护性。
总之，改进一个程序需要考虑多个方面，包括代码质量、性能优化、用户交互性、异常处理、测试覆盖率等。通过不断优化和改进，可以让程序更加健壮和高效。
浙公网安备 33010602011771号