第一次博客作业

一、前言

第一次作业:

1. 计算BMI值：

   • 输入体重(weight)和身高(height)，计算BMI指数。
   • 根据BMI指数判断体重状况，输出相应的结果。

2. 转换单位：

   • 输入体重(weightKg)和长度(lengthM)的值。
   • 将体重转换为磅(weightLb)和长度转换为英寸(lengthIn)。
   • 输出转换后的结果。

3. 求奇数之和：

   • 输入一串以空格分隔的整数。
   • 将其中的奇数相加求和。
   • 输出奇数之和。

4. 计算费用：

   • 输入一个整数(a)、两个整数(b, c)和一个浮点数(d)。
   • 根据不同条件计算出费用(q, w, e, p)。
   • 输出费用。

5. 选择角色：

   • 输入两个整数(raceOption, roleOption)。
   • 根据选项选择角色(race)和职业(role)。
   • 输出选择结果。

6. 解析学号：

   • 输入一个字符串(studentNumber)，代表学号。
   • 解析学号的各个部分，包括入学年份(admissionYear)、学院(college)、班级(classNumber)和学号(studentID)。
   • 输出解析结果。

7. 计算平方根：

   • 输入两个浮点数(n, lastGuess)。
   • 根据牛顿迭代法计算出平方根(result)。
   • 输出结果。

8. 提取二进制：

   • 输入一个字符串(a)，可能包含二进制数字。
   • 提取出字符串中的二进制数字(b)。
   • 输出提取结果。

9. 判断三角形类型：

   • 输入三个浮点数(a, b, c)，代表三角形的边长。
   • 判断并输出三角形的类型，包括等边三角形、等腰直角三角形、直角三角形和一般三角形。

这些程序涵盖了不同的知识点，包括输入输出、条件语句、循环、字符串处理以及数学计算等。题量适中，难度逐渐增加。可以通过阅读和理解每个程序的功能和实现方式来提高对Java语言的掌握和编程能力。

第二次作业:

1. 类和对象：代码中定义了多个类，如Student、Score等，用于封装学生和成绩信息，通过创建对象来使用这些类。
2. 构造方法和成员方法：在Student和Score类中定义了构造方法和成员方法，用于初始化对象和获取对象的属性和方法。
3. 数组和集合：代码中使用了数组和集合来存储多个学生和科目的信息。
4. 输入输出：代码通过Scanner实现了从控制台读取输入，并通过System.out.println输出结果。
5. 字符串处理和格式化输出：代码中使用了字符串的分割和拼接操作，以及格式化输出数字。
6. 输入输出：使用Scanner类进行输入和输出，通过nextInt()、nextDouble()等方法获取用户输入的整数和浮点数，并通过printf()方法格式化输出结果。
7. 数组和循环：定义了多个类，其中Menu类包含一个菜单数组dishes，通过循环遍历该数组来查找特定的菜品对象。
8. 类和对象：定义了Dish、Menu、Record和Order四个类，分别表示菜品、菜单、订单记录以及订单。这些类包含属性和方法，用于描述和操作不同的对象。
9. 异常处理：在第二段代码中，通过try-catch语句捕获DateTimeParseException异常，处理无效的日期字符串输入。日期和时间处理：使用LocalDate类和相关方法解析和处理日期，计算日期之间的差异。

         这次题目数量适中，难度逐渐增加

第三次作业:

1. 日期时间操作：使用Java的LocalDate和相关方法进行日期解析、比较和计算。
2. 异常处理：使用try-catch语句捕获和处理可能抛出的DateTimeParseException异常。
3. 字符串解析和拼接：使用split方法和字符串拼接完成对输入字符串的解析和输出结果的拼接。
4. 接口的实现：代码中Student类实现了Comparable接口，并重写了compareTo方法，用于对象之间的比较。
5. 抽象类的定义：代码中定义了Grade抽象类，并在其子类ExamGrade和AssessGrade中实现了抽象方法。
6. 正则表达式的使用：代码中的InputMatching类使用正则表达式对输入进行匹配，判断输入是否符合要求。
7. 方法的使用：代码中定义了一些方法，如getAvgUsualScore和getAvgFinalScore，用于计算平均分数。

二、设计与分析

 

 

 

 

第二次作业7-1

 

 

这段代码是一个基本的Java程序，其功能是实现对学生信息（包括学生ID、姓名、语文成绩、数学成绩和物理成绩）进行统计，并计算每个学生的总分和平均分。具体实现过程如下：

1. 定义了一个Student类，包含了该类实例的构造函数、getTotalScore()方法（计算总分）和getAverageScore()方法（计算平均分），以及toString()方法（用于输出学生信息）。

2. 在main()方法中，先使用Scanner类读取控制台输入的五行学生信息，并根据空格进行字符串分割，然后将每个学生的信息封装成一个Student对象，存入students数组中。

3. 遍历students数组，对每个学生对象调用toString()方法输出其总分和平均分。

心得：这段代码展示了Java中类和对象的基本概念，以及数组的使用方法。在代码实现过程中，需要注意类型转换的问题，例如将字符串转换为数字类型（使用Integer.parseInt()方法），或者计算平均分时需要进行double类型转换等

第二次作业7-2

 

 

这段代码实现了一个学生成绩管理程序。它定义了两个类：Score表示学生的单科成绩，Student表示学生信息及其多个科目的成绩。代码通过读取控制台输入，依次为每个学生创建对象，并添加相应科目的成绩。最后将学生信息和成绩统计输出。

在Score类中，private修饰的成员变量dailyScore和finalScore分别表示学生的平时成绩和期末成绩。getTotalScore()方法根据平时成绩和期末成绩的权重计算总成绩。

在Student类中，private修饰的成员变量studentNumber和name分别表示学生的学号和姓名。scores是一个Map集合，用于存储学生的科目和对应的成绩对象。addScore()方法可以为学生添加某科目的成绩。getTotalScore()方法遍历所有科目的成绩对象，计算并返回学生的总成绩。getAverageScore()方法根据总成绩和科目数计算学生的平均成绩。toString()方法用于将学生的信息和成绩格式化为字符串。

在Main类的main()方法中，首先创建一个Scanner对象用于读取用户输入。然后创建长度为3的Student数组students。通过循环读取用户输入的学生信息，并使用split()方法将一行输入按空格分割为数组。接着获取学号、姓名、科目、平时成绩和期末成绩，并创建Score对象。根据索引i判断当前学生是否已经创建，如果未创建，则创建一个新的Student对象。将科目和成绩添加到学生对象的scores集合中。循环结束后，遍历students数组，输出每个学生的信息和统计数据。

心得：这段代码展示了面向对象编程的思想，在设计上合理地利用了类和对象的概念，通过建立Student和Score两个类的关联实现了学生成绩的管理。同时，这段代码也展示了Java中使用集合类存储和处理数据的方法，尤其是Map集合的使用。

第二次作业7-7

 

 

 

这段代码实现了一个简单的菜单点餐系统。它包括菜单(Menu)、菜品(Dish)、订单(Order)和记录(Record)四个类。

在Main类的main()方法中，首先创建了一个Scanner对象用于接收用户输入。然后创建了Menu和Order的实例。通过循环读取用户输入的菜品名称和份数，并根据菜单中的菜品名查找对应的Dish对象。如果菜品不存在，则提示不存在并继续下一轮循环。如果菜品存在，则将菜品对象和份数作为参数调用Order对象的addARecord()方法，将记录添加到订单中。循环结束后，调用Order对象的getTotalPrice()方法计算订单的总价格，并输出结果。

Dish类表示菜品，包括名称(name)和单价(unit_price)两个属性。其中，getPrice()方法根据不同的份数计算并返回菜品的价格。

Menu类表示菜单，包含一个Dish数组dishes。在构造函数中初始化了菜单的初始菜品信息，并提供了一个searchDish()方法用于根据菜品名称查找对应的Dish对象。

Record类表示一条记录，包含菜品对象(dish)和份数(portion)。构造函数接收这两个参数，并提供了一个getPrice()方法用于计算记录的价格。

Order类表示订单，包含一个Record数组records和一个整数size来追踪订单中的记录数量。在构造函数中初始化了一个固定大小的records数组。提供了addARecord()方法用于添加记录，以及getTotalPrice()方法用于计算订单的总价格。

通过这个示例代码，我们可以学习到如何使用类和对象来模拟一个简单的点餐系统，并且体会到面向对象编程的思想和设计原则，如封装、继承和多态等。同时，还展示了如何利用数组和循环来管理和操作多个对象。

第三次作业7-2

 

 

这段代码是一个成绩管理系统的主要逻辑部分。它通过解析用户输入信息，包括课程信息和学生成绩信息，并将其存储在相应的列表中。然后，根据用户的需求，显示学生、课程和班级的成绩情况。

代码中的ParseInput类负责解析用户输入的每一行数据，并根据输入的格式进行相应的处理。它通过调用InputMatching类的方法来匹配输入字符串的格式，并根据不同的标记进行不同的操作。

courseMessage方法用于处理课程信息。它解析输入字符串，获取课程名、类型和考试类型，并创建一个Course对象来表示该课程。然后，通过调用checkCourse方法来检查课程类型和考试类型是否匹配，并将课程添加到listCourse列表中。

gradeMessage方法用于处理学生成绩信息。它解析输入字符串，获取学生学号、姓名、课程名以及可能的考试成绩。首先，它检查班级是否存在，如果不存在则创建一个新的班级。然后，创建一个Student对象表示学生，并将其添加到listStudent列表中。接下来，它检查课程是否存在，如果不存在则输出提示信息。如果课程存在，并且输入的考试成绩格式正确，则创建一个ChooseCourse对象来表示学生选课和成绩信息，并将其添加到listChooseCourse列表中。

checkCourse方法用于检查课程类型和考试类型是否匹配。根据课程类型和考试类型的不同，它输出相应的错误提示信息。

searchClass、searchCourse和searchStudent方法用于在班级列表、课程列表和学生列表中搜索相应的对象。

searchChooseCourse方法用于检查是否有重复选课成绩。

showStudents、showCourses和showClasses方法分别用于显示学生、课程和班级的成绩信息。它们首先对相应的列表进行排序，然后遍历列表并计算平均成绩，并输出相应的信息。

在代码中，InputMatching类用于定义输入信息的匹配规则，提供了matchingInput方法用于判断输入字符串属于哪种类型的信息。另外，还提供了静态变量scoreInput1和scoreInput2作为成绩信息的匹配规则，用于匹配学号、姓名、课程名和成绩信息。

该代码适用于小规模的成绩管理，可以根据班级查询学生选修的课程和成绩信息，并计算总分、平时成绩和期末成绩的平均值。但是，该代码仍然存在一定的局限性，无法处理复杂的成绩信息，如多次考试、多种考核方式等。

三、采坑心得

第一次作业

7-8 jmu-java-日期类的基本使用

 
import java.util.Scanner;

public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
double a = input.nextDouble();
double b = input.nextDouble();
double c = input.nextDouble();

if (!isValidInput(a, b, c)) {
System.out.println("Wrong Format");
return;
}

if (a + b <= c || a + c <= b || b + c <= a) {
System.out.println("Not a triangle");
return;
}

if (a == b && b == c) {
System.out.println("Equilateral triangle");
} else if (a * a + b * b - c * c < 0.1 || a * a + c * c - b * b <0.1|| b * b + c * c -a * a<0.1) {
if (a == b || b == c || a == c) {
System.out.println("Isosceles right-angled triangle");
} else {
System.out.println("Right-angled triangle");
}
} else if (a == b || b == c || a == c) {
System.out.println("Isosceles triangle");
} else {
System.out.println("General triangle");
}
}

public static boolean isValidInput(double a, double b, double c) {
return (a >= 1 && a <= 200 && b >= 1 && b <= 200 && c >= 1 && c <= 200);
}
}

 

 

 

一开始一直过不了判断等边直角三角形的那个点，后面发现判断直角三角形不能使用a * a + b * b == c * c，因为这里根号2只能精确到小数点后几位，而不会完全等于根号2，导致算出来的结果并不会相同，因此需要使用a * a + b * b - c * c < 0.1 判断

第二次作业

7-7 菜单计价程序-1

import java.time.LocalDate;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoUnit;
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String dateStr = in.nextLine();
String[] dateRange = in.nextLine().split(" ");
LocalDate startDate, endDate;

// 检查第一行日期字符串是否有效
try {
startDate = LocalDate.parse(dateStr); // 解析日期字符串
} catch (DateTimeParseException e) {
System.out.println(dateStr + "无效!");

System.out.println(dateRange[0] + "或" + dateRange[1] + "中有不合法的日期.");
return;
}

// 输出第一行日期相关信息
System.out.println(getDateInfo(startDate));

// 解析并输出第二行日期相关信息
startDate = LocalDate.parse(dateRange[0]); // 解析开始日期字符串
endDate = LocalDate.parse(dateRange[1]); // 解析结束日期字符串
System.out.println(getDateRangeInfo(startDate, endDate));
}

public static boolean checkDatesValidity(String startDate, String endDate) {
try {
LocalDate.parse(startDate); // 检查开始日期是否有效
LocalDate.parse(endDate); // 检查结束日期是否有效
return true;
} catch (DateTimeParseException e) {
return false;
}
}

public static String getDateInfo(LocalDate date) {
int dayOfYear = date.getDayOfYear();
int dayOfMonth = date.getDayOfMonth();
int dayOfWeek = date.getDayOfWeek().getValue();

String info =date.toString();
if (isLeapYear(date.getYear())) {
info += "是闰年.\n";
} else {
info += "\n";
}
info +=date.toString() + "是当年第" + dayOfYear + "天,当月第" + dayOfMonth + "天,当周第" + dayOfWeek + "天.";
return info;
}

public static String getDateRangeInfo(LocalDate startDate, LocalDate endDate) {
if (endDate.isBefore(startDate)) {
return endDate.toString() + "早于" + startDate.toString() + ",不合法!";
}

long daysDiff = ChronoUnit.DAYS.between(startDate, endDate);
int monthsDiff = endDate.getMonthValue() - startDate.getMonthValue();
int yearsDiff = endDate.getYear() - startDate.getYear();

String info = endDate.toString() + "与" + startDate.toString() + "之间相差" + daysDiff + "天,所在月份相差" +
monthsDiff + ",所在年份相差" + yearsDiff + ".";
return info;
}

public static boolean isLeapYear(int year) {
return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
}
}

 

日期均有效，但第二行结束日期早于其实日期  这个点一开始一直过不去，后面发现是因为日期打印了两次，导致重复了，所以后面改成了

public static String getDateInfo(LocalDate date) {
int dayOfYear = date.getDayOfYear();
int dayOfMonth = date.getDayOfMonth();
int dayOfWeek = date.getDayOfWeek().getValue();

String info =date.toString();
if (isLeapYear(date.getYear())) {
info += "是闰年.\n";
} else {
info += "\n";
}
info +=date.toString() + "是当年第" + dayOfYear + "天,当月第" + dayOfMonth + "天,当周第" + dayOfWeek + "天.";
return info;
}

 

就能成功过去这个测试点

第三次作业

7-3 面向对象编程(封装性)

import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 调用无参构造方法，并通过setter方法进行设值
String sid1 = sc.next();
String name1 = sc.next();
int age1 = sc.nextInt();
String major1 = sc.next();
Student student1 = new Student();
student1.setSid(sid1);
student1.setName(name1);
student1.setAge(age1);
student1.setMajor(major1);
// 调用有参构造方法
String sid2 = sc.next();
String name2 = sc.next();
int age2 = sc.nextInt();
String major2 = sc.next();
Student student2 = new Student(sid2, name2, age2, major2);
// 对学生student1和学生student2进行输出
student1.print();
student2.print();
}
}

class Student {
private String sid;
private String name;
private int age;
private String major;

public Student() {

}

public Student(String sid, String name, int age, String major) {
this.sid = sid;
this.name = name;
setAge(age); // 调用setAge()方法进行年龄判定
this.major = major;
}

public void setSid(String sid) {
this.sid = sid;
}

public String getSid() {
return sid;
}

public void setName(String name) {
this.name = name;
}

public String getName() {
return name;
}

public void setAge(int age) {
if (age > 0)
this.age = age;
}

public int getAge() {
return age;
}

public void setMajor(String major) {
this.major = major;
}

public String getMajor() {
return major;
}

public void print() {
System.out.println("学号：" + sid + "，姓名：" + name + "，年龄：" + age + "，专业：" + major);
}
}

 

一开始出现问题Main.java:3: error: class Student is public, should be declared in a file named Student.java public class Student { ^ 1 error

后面发现导入语句应该放在类的外部，并且需要将Student类和Main类放在同一个文件中。

7-4 判断两个日期的先后，计算间隔天数、周数

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-M-d");

String dateString1 = scanner.nextLine();
String dateString2 = scanner.nextLine();

// 解析输入字符串生成日期对象
LocalDate date1 = LocalDate.parse(dateString1, formatter);
LocalDate date2 = LocalDate.parse(dateString2, formatter);

// 判断两个日期之间的先后顺序
if (date1.isBefore(date2)) {
System.out.println("第一个日期比第二个日期更早");
} else if (date1.isAfter(date2)) {
System.out.println("第一个日期比第二个日期更晚");
} else {
System.out.println("两个日期相同");
}

// 计算两个日期之间的绝对天数
long daysBetween = Math.abs(ChronoUnit.DAYS.between(date1, date2));
System.out.println("两个日期间隔" + daysBetween + "天");

// 计算两个日期之间的周数
long weeksBetween = Math.abs(ChronoUnit.WEEKS.between(date1, date2));
System.out.println("两个日期间隔" + weeksBetween + "周");
}
}

 

一开始如果前面的时间大于后面的时间，会得到间隔-X天，后面使用Math.abs()方法来获取绝对值，就可以正确得到间隔多少天

四、主要困难以及改进建议

第三次作业7-2

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-M-d");

String dateString1 = scanner.nextLine();
String dateString2 = scanner.nextLine();

// 解析输入字符串生成日期对象
LocalDate date1 = LocalDate.parse(dateString1, formatter);
LocalDate date2 = LocalDate.parse(dateString2, formatter);

// 判断两个日期之间的先后顺序
if (date1.isBefore(date2)) {
System.out.println("第一个日期比第二个日期更早");
} else if (date1.isAfter(date2)) {
System.out.println("第一个日期比第二个日期更晚");
} else {
System.out.println("两个日期相同");
}

// 计算两个日期之间的绝对天数
long daysBetween = Math.abs(ChronoUnit.DAYS.between(date1, date2));
System.out.println("两个日期间隔" + daysBetween + "天");

// 计算两个日期之间的周数
long weeksBetween = Math.abs(ChronoUnit.WEEKS.between(date1, date2));
System.out.println("两个日期间隔" + weeksBetween + "周");
}
}

 

在写这道题的时候，总是只能过几个测试点

这段代码是一个简单的成绩管理系统，通过命令行输入课程信息和学生成绩，然后计算每个学生的平均分，并输出学生的成绩信息和课程无成绩信息。

在分析困难之前，我们需要先了解代码中的一些问题：

1. 缺乏错误处理机制：代码中并没有充分考虑异常情况的处理，当输入格式不正确或数据不匹配时，仅仅简单地输出错误信息。

2. 数据结构设计不够合理：学生和课程之间的关系使用了嵌套的数据结构，这样会导致查询和操作数据时的复杂度增加。

3. 可读性不高：代码中使用了一些魔法数值和变量命名不规范，不利于代码维护和阅读。

基于以上问题，我们可以提出一些改进的见解：

1. 引入异常处理机制：对于输入格式错误、数据不匹配等异常情况，可以使用异常处理来捕获和处理，给出更具体的错误信息。

2. 使用合适的数据结构：可以使用更合适的数据结构来表示学生和课程之间的关系，例如使用 Map<学生ID, 学生对象> 和 Map<课程名称, 课程对象>，这样可以提高查询和操作数据的效率。

3. 使用常量代替魔法数值：将代码中的一些魔法数值抽取为常量，并使用有意义的变量命名，以提高代码的可读性。

4. 模块化设计：可以将输入解析和计算平均分的逻辑模块化，分别封装为独立的方法，提高代码的可维护性和可扩展性。

5. 添加注释：在代码中添加必要的注释，对关键逻辑进行解释，提高代码的可读性和易理解性。

下面是对代码的改进示例：

import java.util.*;

public class Main {

static class Course {
String name;
String type;
String mode;

public Course(String name, String type, String mode) {
this.name = name;
this.type = type;
this.mode = mode;
}
}

static class Student {
int id;
String name;
Map<String, int[]> scores = new HashMap<>();

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

static Map<String, Course> courseMap = new HashMap<>();
static Map<Integer, Student> studentMap = new HashMap<>();
static Scanner scanner = new Scanner(System.in);

// 解析课程信息
static void parseCourseInfo(String line) {
String[] parts = line.split(" ");
if (parts.length != 3) {
throw new IllegalArgumentException("wrong format");
}
String name = parts[0];
String type = parts[1];
String mode = parts[2];

if (courseMap.containsKey(name)) {
throw new IllegalArgumentException(name + " exists");
}

courseMap.put(name, new Course(name, type, mode));
}

// 解析成绩信息
static void parseScoreInfo(String line) {
String[] parts = line.split(" ");
if (parts.length != 5) {
throw new IllegalArgumentException("wrong format");
}
int id = Integer.parseInt(parts[0]);
String name = parts[1];
String courseName = parts[2];
int dailyScore, examScore;
try {
dailyScore = Integer.parseInt(parts[3]);
examScore = Integer.parseInt(parts[4]);
} catch (NumberFormatException e) {
throw new IllegalArgumentException("wrong format");
}

Course course = courseMap.get(courseName);
if (course == null) {
throw new IllegalArgumentException(courseName + " does not exist");
}

if (!course.mode.equals("exam") && (dailyScore < 0 || dailyScore > 100 || examScore < 0 || examScore > 100)) {
throw new IllegalArgumentException("wrong format");
}

if (!course.match(courseName, "mandatory", "exam")) {
throw new IllegalArgumentException(courseName + ": course type & access mode mismatch");
}

Student student = studentMap.get(id);
if (student == null) {
student = new Student(id, name);
studentMap.put(id, student);
}

int[] scores = student.scores.get(courseName);
if (scores == null) {
scores = new int[2];
scores[0] = dailyScore;
scores[1] = examScore;
student.scores.put(courseName, scores);
}
}

// 计算学生的平均分
static double calculateAverage(Student student) {
double totalAverage = 0.0;
boolean hasGrades = false; // 是否有成绩
for (int[] scores : student.scores.values()) {
double average = 0.0;
if (course.mode.equals("exam")) {
average = scores[1];
} else {
average = 0.4 * scores[0] + 0.6 * scores[1];
}
totalAverage += average;
hasGrades = true;
}
return hasGrades ? totalAverage / student.scores.size() : 0.0;
}

// 输出学生信息
static void printStudentInfo(Student student) {
double overallAverage = calculateAverage(student);

System.out.printf("%d %s %.0f%n", student.id, student.name, overallAverage);

// 输出课程成绩信息
for (Map.Entry<String, int[]> entry : student.scores.entrySet()) {
String courseName = entry.getKey();
int[] scores = entry.getValue();
System.out.printf("%s %d %d %.0f%n", courseName, scores[0], scores[1], (scores[0] + scores[1]) / 2.0);
}

// 输出课程无成绩信息
for (Course course : courseMap.values()) {
if (!student.scores.containsKey(course.name)) {
System.out.println(course.name + " has no grades yet");
}
}
}

public static void main(String[] args) {
String line;
while (!(line = scanner.nextLine()).equals("end")) {
if (line.isEmpty()) {
continue;
}
if (!line.contains(" ")) {
throw new IllegalArgumentException("wrong format");
}
String[] parts = line.split(" ");
if (parts.length == 3) {
parseCourseInfo(line);
} else if (parts.length == 5) {
parseScoreInfo(line);
} else {
throw new IllegalArgumentException("wrong format");
}
}

for (Student student : studentMap.values()) {
printStudentInfo(student);
}
}
}

 

五、总结

在本阶段的三次题目集中，我们通过解答具体问题和实践编码，学到了以下几点：

1. 编程能力的提升：通过解答题目集中的编程题，我们锻炼了自己的编程能力，包括算法设计、数据结构运用、异常处理等方面。

2. 代码规范和可读性的重要性：在完成编程题目的过程中，我们意识到编写规范化、可读性高的代码对于代码的维护和交流非常重要。

3. 实际问题的分析和解决能力：在解答题目时，我们需要仔细分析问题，理清思路，并使用合适的算法和数据结构来解决问题，这培养了我们解决实际问题的能力。

需要进一步学习和研究的地方包括：

1. 算法和数据结构：我们可以进一步学习和深入了解常见的算法和数据结构，以便在解决更复杂的问题时有更好的选择和优化。

2. 异常处理和错误处理：为了编写更健壮的代码，我们可以深入研究异常处理和错误处理机制，提高代码的稳定性和可靠性。

3. 设计模式和代码架构：对于大型项目或系统，学习设计模式和良好的代码架构可以提高项目的可维护性和扩展性。

对于教师、课程、作业、实验、课上及课下组织方式等方面的改进建议和意见，可以有以下几点：

1. 提供更多编程题目和实践机会：编程能力需要不断的练习和实践，在增加编程题目和实践机会的同时，教师可以提供相应的代码评审和指导，帮助学生提升编程能力。

2. 强调代码规范和可读性：在课程中加强对代码规范和可读性的教育，培养学生良好的编码习惯和代码风格，这对于团队协作和代码维护非常重要。

3. 引入实际项目开发经验：可以让学生参与到实际的项目开发中，提供机会让学生在真实的场景中应用所学知识，加深对软件工程的理解。

4. 加强算法和数据结构的教学：算法和数据结构是计算机科学的核心基础，加强教学并提供更多的练习和实践机会，可以提高学生在解决实际问题时的能力。

5. 鼓励自主学习和研究：在课程中鼓励学生进行自主学习和探索，培养其自主学习和解决问题的能力，可以通过提供相关资源和引导学生参与开源项目等方式来实现。

总之，通过更多的练习和实践，不断学习和研究，加强对算法、数据结构和编程规范的理解，我们可以进一步提升自己的编程水平和解决问题的能力。同时，针对教师、课程等方面，通过改进和优化教学内容和组织方式，可以更好地培养学生的编程能力和软件工程素养。