BLOG-1-7213

创建成绩类，包含：

属性：平时成绩（int）、期末成绩（int）

方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）

创建学生类，包含：

属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）

方法：计算总分、计算平均分

输入3个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。

浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365

注意：未用学生类对象封装数据的，本题计0分

输入格式:

依次输入3个学生的每门课成绩，每个学生成绩信息格式：

学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致

例如：
22201311 张琳 语文 70 80

22201311 张琳 数学 85 89

22201311 张琳 物理 75 83

22201312 黄昊 语文 66 78

22201312 黄昊 数学 76 82

22201312 黄昊 物理 83 82

22201313 李少辰 语文 86 76

22201313 李少辰 数学 78 76

22201313 李少辰 物理 87 76

输出格式:

3个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分

例如：

22201311 张琳 242 80.67

22201312 黄昊 234 78.00

22201313 李少辰 236 78.67

输入样例:

在这里给出一组输入。例如：

22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76

输出样例:

在这里给出相应的输出。例如：

22201311 张琳 242 76.67 84.00 80.67
22201312 黄昊 234 75.00 80.67 78.00
22201313 李少辰 236 83.67 76.00 78.67

这段代码是一个学生成绩管理系统，可以输入学生的信息和课程成绩，然后计算总成绩和平均成绩，并输出结果。

首先，在Score类中定义了一个构造函数和一些getter和setter方法来设置和获取平时成绩和期末成绩。还有一个calculateTotalScore()方法，通过加权计算得到课程的最终成绩。

接下来，在Student类中定义了学生的基本信息和各科成绩，通过setScore()方法来设置每门科目的成绩。calculateTotalScore()方法用来计算学生的总成绩，calculateAverageScore()方法用来计算学生的平均成绩。

calculatepinshiAverageScore()方法和calculateqimoAverageScore()方法分别用来计算学生的平时成绩和期末成绩的平均值。print()方法用来输出学生的信息和成绩。

最后，在Main类的main方法中使用Scanner类来输入学生信息和成绩。通过循环遍历输入的学生信息，并通过判断学生是否存在来更新学生的成绩或创建新的学生对象。最后，再通过循环遍历输出学生的信息和成绩。

通过封装和继承的方式建立了Score和Student类，并使用了数组来存储多个学生对象，实现了学生成绩的管理和输出。

原码如下：

import java.util.*;
import java.text.DecimalFormat;
class Score {
private int pinshiScore;
private int qimoScore;

public Score(int pinshiScore, int qimoScore) {
this.pinshiScore = pinshiScore;
this.qimoScore = qimoScore;
}
public void setPinshiScore(){
pinshiScore = pinshiScore;
}
public void setQimoScore(){
qimoScore = qimoScore;
}
public int getPinshiScore(){
return this.pinshiScore;
}
public int getQimoScore(){
return this.qimoScore;
}

public int calculateTotalScore() {//计算课程成绩
return (int) (pinshiScore * 0.4 + qimoScore * 0.6);
}
}

class Student {
String studentId;
String name;
Score chineseScore;
Score mathScore;
Score physicsScore;

public Student(String studentId, String name) {
this.studentId = studentId;
this.name = name;
}

public void setScore(String course, int pinshiScore, int qimoScore) {//得到课程成绩
switch (course) {
case "语文":
chineseScore = new Score(pinshiScore, qimoScore);
break;
case "数学":
mathScore = new Score(pinshiScore, qimoScore);
break;
case "物理":
physicsScore = new Score(pinshiScore, qimoScore);
break;
default:
break;
}
}

public int calculateTotalScore() {//计算总成绩
int totalScore = 0;
totalScore += chineseScore.calculateTotalScore();
totalScore += mathScore.calculateTotalScore();
totalScore += physicsScore.calculateTotalScore();
return totalScore;

}

public double calculateAverageScore() {
int totalScore = calculateTotalScore();
return (double) totalScore / 3;
}
public double calculatepinshiAverageScore(){
int totalScore = 0;
totalScore += chineseScore.getPinshiScore();
totalScore += mathScore.getPinshiScore();
totalScore += physicsScore.getPinshiScore();
return (double) totalScore / 3;
}
public double calculateqimoAverageScore(){
int totalScore = 0;
totalScore += chineseScore.getQimoScore();
totalScore += mathScore.getQimoScore();
totalScore += physicsScore.getQimoScore();
return (double) totalScore / 3;
}

public void print() {//输出
int totalScore = calculateTotalScore();
double averageScore = calculateAverageScore();
double averagepinshiScore = calculatepinshiAverageScore();
double averageqimoScore = calculateqimoAverageScore();
DecimalFormat df = new DecimalFormat("0.00");
System.out.println(studentId + " " + name + " " + totalScore + " " + df.format(averagepinshiScore)+ " " + df.format(averageqimoScore)+ " " + df.format(averageScore));
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Student[] students = new Student[3];

for (int i = 0; i < 9; i++) {
String input = scanner.nextLine();
String[] tokens = input.split(" ");
String studentId = tokens[0];
String name = tokens[1];
String course = tokens[2];
int pinshiScore = Integer.parseInt(tokens[3]);
int qimoScore = Integer.parseInt(tokens[4]);

boolean studentExists = false;
for (int j = 0; j < 3; j++) {
if (students[j] != null && students[j].studentId.equals(studentId)) {
students[j].setScore(course, pinshiScore, qimoScore);
studentExists = true;
break;
}
}

if (!studentExists) {
for (int j = 0; j < 3; j++) {
if (students[j] == null) {
students[j] = new Student(studentId, name);
students[j].setScore(course, pinshiScore, qimoScore);
break;
}
}
}
}
for (Student student : students) {
if (student != null) {
student.print();
}
}
}
}

菜单计价题

麻婆豆腐 2
西红柿炒蛋 3
end

48

麻婆豆腐 2
炒脆肚 2
西红柿炒蛋 3
end

炒脆肚 does not exist
48

一开始打算使用面向对象的思想来设计程序，使用菜品类、菜谱类、点菜记录类、订单类四个类来组织程序。

首先定义菜品类Dish，包含对应菜品上的信息，如名称和单价，以及计算菜品价格的方法。

然后定义菜谱类Menu，将所有菜品的信息保存在一个菜品数组中，还需要提供根据菜名查找菜品信息的方法。

接下来是点菜记录类Record，包含了一道菜品记录（即菜品和份额），还需提供计价的方法。

最后定义订单类Order，包含了多道菜品记录，提供了添加一道菜品记录到订单的方法，还需提供计算订单总价的方法。

需要注意的地方：当输入的菜名不在菜单中时，输出提示“** does not exist”，菜名为输入的菜名。菜品价格要按照题目要求进行计算。

最后的设计如下

1. Dish类：表示菜品，包含菜品名称和单价属性，并提供了计算指定份数的菜品价格的方法。

2. Menu类：表示菜单，包含了菜品数组，提供了根据菜名查找菜品信息的方法。

3. Record类：表示一道菜品的点菜记录，包含了菜品和份额属性，并提供了计算点菜记录价格的方法。

4. Order类：表示订单，包含了多个点菜记录，提供了添加一道菜品记录和计算订单总价的方法。

5. MenuSystem类：用来初始化菜单，将所有菜品信息保存在菜单对象中。

6. Main类：主程序入口，通过用户输入点菜信息，调用Order类的方法进行记录和计算总价。

这段代码使用了面向对象的设计思想，将功能模块分成不同的类，并且通过类之间的关联和调用完成相应的功能。每个类都承担了特定的责任，增强了代码的可读性和可维护性。

在Main类的main方法中，通过Scanner获取用户输入的点菜信息，然后调用Order类的addARecord方法将点菜记录添加到订单中。如果菜名不存在，在控制台输出相应的提示信息。最后调用Order类的getTotalPrice方法计算订单的总价，并输出到控制台。

原码：

import java.util.Scanner;

class Dish {
private String name;
private int unitPrice;

public Dish(String name, int unitPrice) {
this.name = name;
this.unitPrice = unitPrice;
}

public String getName() {
return name;
}

public int getUnitPrice() {
return unitPrice;
}

public int getPrice(int portion) {
if (portion == 1) {
return unitPrice;
} else if (portion == 2) {
return Math.round(unitPrice * 1.5f);
} else if (portion == 3) {
return unitPrice * 2;
} else {
return -1;
}
}
}

class Menu {
private Dish[] dishes;

public Menu(Dish[] dishes) {
this.dishes = dishes;
}

public Dish searchDish(String dishName) {
for (Dish dish : dishes) {
if (dish.getName().equals(dishName)) {
return dish;
}
}
return null;
}
}

class Record {
private Dish dish;
private int portion;

public Record(Dish dish, int portion) {
this.dish = dish;
this.portion = portion;
}

public int getPrice() {
if (dish == null) {
return -1;
}
return dish.getPrice(portion);
}
}

class Order {
private Record[] records;

public Order() {
records = new Record[10];
}

public int getTotalPrice() {
int totalPrice = 0;
boolean hasInvalidDish = false;
for (Record record : records) {
if (record != null) {
int price = record.getPrice();
if (price != -1) {
totalPrice += price;
} else {
hasInvalidDish = true;
}
}
}
if (hasInvalidDish) {
return -1;
}
return totalPrice;
}

public Record addARecord(String dishName, int portion) {
Dish dish = MenuSystem.menu.searchDish(dishName);
if (dish == null) {
return null;
}
Record record = new Record(dish, portion);
for (int i = 0; i < records.length; i++) {
if (records[i] == null) {
records[i] = record;
break;
}
}
return record;
}
}

class MenuSystem {
public static Menu menu;

static {
Dish[] dishes = {
new Dish("西红柿炒蛋", 15),
new Dish("清炒土豆丝", 12),
new Dish("麻婆豆腐", 12),
new Dish("油淋生菜", 9)
};
menu = new Menu(dishes);
}
}

public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Order order = new Order();

while (sc.hasNextLine()) {
String line = sc.nextLine().trim();
if (line.equals("end")) {
break;
}

String[] tokens = line.split("\\s+");
if (tokens.length != 2) {
continue;
}

String dishName = tokens[0];
int portion = Integer.parseInt(tokens[1]);

Record record = order.addARecord(dishName, portion);
if (record == null) {
System.out.println(dishName + " does not exist");
}
}

int totalPrice = order.getTotalPrice();
System.out.println(totalPrice);
}
}

题集3 7-2

java 必修 考试
数据结构 选修 考试
形式与政治 选修 考察
end

java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet

java 必修 考试
20201103 张三 java 20 40
end

20201103 张三 34
java 20 40 34
202011 34

java 选修 考察
20201103 张三 java 40
end

20201103 张三 40
java 40 40
202011 40

java 必修 考试
20201103 张三 java 20
end

20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet

java 必修 考察
20201103 张三 java 40
end

java : course type & access mode mismatch
java does not exist
20201103 张三 did not take any exams
202011 has no grades yet

java 选修 考察
20201103 李四 java 60
20201104 王五 java 60
20201101 张三 java 40
end

20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201103 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201103 李四 java 60
20201103 李四 数据库 70 78
end

20201103 李四 73
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73

数据结构 选修 考察
20201103 李四 数据结构 101
end

wrong format
数据结构 has no grades yet

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201205 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201102 王五 java 60
20201211 张三 数据库 70 78
end

20201102 王五 60
20201103 李四 87
20201205 李四 70
20201211 张三 75
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
202012 72

一直到最后依旧存在一些问题没有解决，无法通过一些测试点

源码

import java.util.*;

class Course {
private String name; // 课程名称
private String nature; // 课程性质
private String assessment; // 考核方式

public Course(String name, String nature, String assessment) {
this.name = name;
this.nature = nature;
this.assessment = assessment;
}

public String getName() {
return name;
}

public String getNature() {
return nature;
}

public String getAssessment() {
return assessment;
}
}

class Grade {
private String studentId; // 学号
private String name; // 姓名
private String courseName; // 课程名称
private int regularGrade; // 平时成绩
private int finalGrade; // 期末成绩

public Grade(String studentId, String name, String courseName, int regularGrade, int finalGrade) {
this.studentId = studentId;
this.name = name;
this.courseName = courseName;
this.regularGrade = regularGrade;
this.finalGrade = finalGrade;
}

public String getStudentId() {
return studentId;
}

public String getName() {
return name;
}

public String getCourseName() {
return courseName;
}

public int getRegularGrade() {
return regularGrade;
}

public int getFinalGrade() {
return finalGrade;
}
}

public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
List<Course> courses = new ArrayList<>();
List<Grade> grades = new ArrayList<>();
String input;

while (!(input = scanner.nextLine().trim()).equals("end")) {
String[] tokens = input.split("\\s+");
if (tokens.length == 1 && tokens[0].isEmpty()) {
continue;
}

if (tokens.length != 3) {
System.out.println("wrong format");
return;
}

String courseName = tokens[0];
String nature = tokens[1];
String assessment = tokens[2];

Course course = new Course(courseName, nature, assessment);
courses.add(course);
}

while (scanner.hasNextLine()) {
input = scanner.nextLine().trim();
if (input.isEmpty()) {
continue;
}

String[] tokens = input.split("\\s+");
if (tokens.length != 6 && tokens.length != 5) {
System.out.println("wrong format");
return;
}

String studentId = tokens[0];
String name = tokens[1];
String courseName = tokens[2];
int regularGrade = -1;
int finalGrade = -1;

try {
if (tokens.length == 6) {
regularGrade = Integer.parseInt(tokens[3]);
finalGrade = Integer.parseInt(tokens[4]);
}
else {
finalGrade = Integer.parseInt(tokens[3]);
}
} catch (NumberFormatException e) {
System.out.println("wrong format");
return;
}

Grade grade = new Grade(studentId, name, courseName, regularGrade, finalGrade);
grades.add(grade);
}

Map<String, List<Grade>> gradeMap = new HashMap<>();
Map<String, Double> averageGradeMap = new HashMap<>();
Map<String, Double> regularAverageMap = new HashMap<>();
Map<String, Double> finalAverageMap = new HashMap<>();
Map<String, Integer> totalCountMap = new HashMap<>();
Set<String> classNames = new HashSet<>();

for (Grade grade : grades) {
List<Grade> classGrades = gradeMap.getOrDefault(grade.getStudentId().substring(0, 6), new ArrayList<>());
classGrades.add(grade);
gradeMap.put(grade.getStudentId().substring(0, 6), classGrades);

double totalGrade = grade.getRegularGrade() * 0.3 + grade.getFinalGrade() * 0.7;

averageGradeMap.put(grade.getStudentId(), averageGradeMap.getOrDefault(grade.getStudentId(), 0.0) + totalGrade);
regularAverageMap.put(grade.getCourseName(), regularAverageMap.getOrDefault(grade.getCourseName(), 0.0) + grade.getRegularGrade());
finalAverageMap.put(grade.getCourseName(), finalAverageMap.getOrDefault(grade.getCourseName(), 0.0) + grade.getFinalGrade());

totalCountMap.put(grade.getCourseName(), totalCountMap.getOrDefault(grade.getCourseName(), 0) + 1);
classNames.add(grade.getStudentId().substring(0, 6));
}

List<String> sortedClassNames = new ArrayList<>(classNames);
Collections.sort(sortedClassNames);

for (String className : sortedClassNames) {
double totalGrade = 0;
int count = 0;

List<Grade> classGrades = gradeMap.get(className);
Collections.sort(classGrades, Comparator.comparing(Grade::getStudentId));

for (Grade grade : classGrades) {
System.out.println(grade.getStudentId() + " " + grade.getName() + " " + (int)(averageGradeMap.get(grade.getStudentId()) / totalCountMap.size()));
totalGrade += averageGradeMap.get(grade.getStudentId());
count++;
}

if (count == 0) {
System.out.println(className + " has no grades yet");
} else {
System.out.println(className + " " + (int)(totalGrade / count));
}
}

List<String> courseNames = new ArrayList<>();
for (Course course : courses) {
courseNames.add(course.getName());
}
Collections.sort(courseNames);

for (String courseName : courseNames) {
double regularAverage = regularAverageMap.getOrDefault(courseName, 0.0) / totalCountMap.getOrDefault(courseName, 0);
double finalAverage = finalAverageMap.getOrDefault(courseName, 0.0) / totalCountMap.getOrDefault(courseName, 0);

System.out.println(courseName + " " + (int)regularAverage + " " + (int)finalAverage + " " +
(int)((regularAverage * 0.3 + finalAverage * 0.7) / totalCountMap.getOrDefault(courseName, 0)));
}
}
}