第一次博客作业

前言

这学期才开始接触Java，之前只学了C语言，所以一开始写题目的代码的时候对Java的众多函数和语法不是太熟悉，一开始就上手写代码有点不适应。

​ 关于类：

1、类似C中的struct，构造函数、内置方法(函数 )都比较相似

2、尽量避免代码的重复，把private和public的方法搞清晰。

3、把我们需要解决的问题进行拆分，拆得好就写得快

三次题目集的知识点、题量、难度等情况

（对于重难点题目将会给出完整题目）

第一次作业：1、 身体质量指数（BMI）测算  2、NCHU_奇数求和  3、NCHU_房产税费计算  4、游戏角色选择  5、NCHU_学号识别 6、NCHU_巴比伦法求平方根近似值 7、二进制数值提取 8、判断三角形类型 9、长度质量计量单位换算

第一次作业较为简单，熟悉了java的一些基本操作，和一些简单函数的运用。

第二次作业：1、成绩计算-1-类、数组的基本运用

2、成绩计算-2-关联类

创建成绩类，包含：

属性：平时成绩（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

 

代码长度限制16 KB

时间限制400 ms

内存限制64 MB

 

3、有重复的数据 4、去掉重复的数据 5、面向对象编程(封装性)  6、GPS测绘中度分秒转换

7、菜单计价程序-1

某饭店提供4种菜，每种菜品的基础价格如下：

西红柿炒蛋 15

清炒土豆丝 12

麻婆豆腐 12

油淋生菜 9

设计点菜计价程序，根据输入的订单，计算并输出总价格。

订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束

每条点菜记录包含：菜名、份额两个信息。

份额可选项包括：1、2、3，分别代表小、中、大份）

不同份额菜价的计算方法：

小份菜的价格=菜品的基础价格。

中份菜的价格=菜品的基础价格1.5。

小份菜的价格=菜品的基础价格2。

如果计算出现小数，按四舍五入的规则进行处理。

 

参考以下类的模板进行设计：

菜品类：对应菜谱上一道菜的信息。

Dish {

String name;//菜品名称

int unit_price; //单价

int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）

}

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。

Menu {

Dish[] dishs ;//菜品数组，保存所有菜品信息

Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。

}

点菜记录类：保存订单上的一道菜品记录

Record {

Dish d;//菜品

int portion;//份额（1/2/3代表小/中/大份）

int getPrice()//计价，计算本条记录的价格

}

订单类：保存用户点的所有菜的信息。

Order {

Record[] records；//保存订单上每一道的记录

int getTotalPrice()//计算订单的总价

Record addARecord(String dishName,int portion)

//添加一条菜品信息到订单中。

}

输入格式:

每条点菜记录的格式：

菜名+空格（英文）+份额

注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。

最后一条记录以“end”结束。

输出格式:

订单上所有菜品的总价（整数数值），每份菜

如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名

 

输入样例:

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

麻婆豆腐 2

西红柿炒蛋 3

End

输出样例:

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

48

 

输入样例1:

订单中包含不存在的菜品记录。例如：

麻婆豆腐 2

炒脆肚 2

西红柿炒蛋 3

End

输出样例1:

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

炒脆肚 does not exist

48

 

代码长度限制 16 KB

时间限制 400 ms

内存限制 64 MB

 

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

第二次作业的第一、二题学生成绩计算，七题菜单计价较为复杂，涉及到的类比较多。这三题的难度较大，一些结构的设计较为繁复。我个人认为第8题的日期计算的代码调试比较困难，因为你必须去猜老师给的测试用例到底是怎么算出来的（ps：老师给的测试用例的输出其实是错的，但是要过测试点的话，错也要和老师提供的一样QAQ

第三次作业：1、jmu-java-日期类的基本使用  

2、课程成绩统计程序-1

某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。

考察的总成绩直接等于期末成绩

必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。

1、输入：

包括课程、课程成绩两类信息。

课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。

课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式

课程性质输入项：必修、选修

考核方式输入选项：考试、考察

课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩

课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩

以上信息的相关约束：

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） 成绩平均分只取整数部分，小数部分丢弃

 

3、面向对象编程(封装性)  4、判断两个日期的先后，计算间隔天数、周数

第三次作业第二题的难度较大，需要建立很多的类，各个类之间的关系也比较复杂，真的很难TAT，测试点还有很多没过。

 

设计与分析与主要问题和其解决方法

（这里只会提供重点题目的重点代码）

第二次作业：题目一（成绩计算-1-类、数组的基本运用）：

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

        int i ;
        //依次输入5个学生的信息
        for(i = 0; i < 5; i++){
            stu[i] = new Student(sc.next(), sc.next(),sc.nextFloat(),sc.nextFloat(),sc.nextFloat());
            float[] totoal = new float[5]; //总成绩
            float[] average = new float[5]; //平均成绩
            totoal[i] = stu[i].getChinese() + stu[i].getMath() + stu[i].getPhysic();
            average[i] = totoal[i]/3;
            System.out.println(stu[i].getIdnum() + " " + stu[i].getName()+ " " + (int)totoal[i] + " " + String.format("%.2f",average[i]));
            stu[i] = null;
        }
    }
}

这题主要要注意成绩和平均成绩不能存为int类型，不然会导致最后结果的四舍五入的结果不太精确，所以这里我们直接选择在最后输出的时候才将总成绩和平均成绩转化成int类型。

 

第二次作业：题目二（成绩计算-2-关联类）：

class Student1 {
    String idnum;
    String name;
    double chinese;
    double math;
    double physic;
    double total;
    double usual_average;
    double final_average;
    public Student1(String idnum, String name, double chinese, double math, double physic,double total,double usual_average,double final_average){
        this.idnum = idnum;//获取学号
        this.name = name;//获取姓名
        this.chinese = chinese;//获取中文成绩
        this.math = math; //获取数学成绩
        this.physic = physic;   //获取物理成绩
        this.total = total;  //获取平时成绩的总分
        this.usual_average = usual_average;
        this.final_average = final_average;
    }
}

class Student2{//学生成绩
    float usual;
    float Final;
    public Student2( float usual, float Final) {
        this.usual = usual;
        this.Final = Final;
    }
}

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

        //依次输入3个学生的信息
        for(int i = 0; i < 3; i++) {//学生
            String student_idnum = "";
            String student_name = "";
            double chinese_grades = 0;//初始化语文成绩
            float chinese_usual = 0;
            float chinese_final = 0;
            double math_grades = 0;//初始化数学成绩
            float math_usual = 0;
            float math_final = 0;
            double physic_grades = 0;//初始化物理成绩
            float physic_usual = 0;
            float physic_final = 0;
            double total_grades ;
            double usual_grades;  //平时成绩的平均分
            double final_grades; //期末成绩的平均分

            for(int j = 0; j < 3; j ++) {
                String str1 = sc.nextLine();//直接读取一整行信息
                //将读取到的信息按一个英文空格进行分割成多个字符串，存在strs数组中，方便后续课程的匹配
                String[] strs = str1.split(" ");
                student_idnum = strs[0];
                student_name = strs[1];
                //判断课程
                if ("语文".equals(strs[2])) {
                    chinese_usual = Float.parseFloat(strs[3]);
                    chinese_final = Float.parseFloat(strs[4]);
                    Student2 Chinese = new Student2(chinese_usual, chinese_final);
                    chinese_grades = chinese_usual * 0.4 + chinese_final * 0.6;
                } else if ("数学".equals(strs[2])) {
                    math_usual = Float.parseFloat(strs[3]);
                    math_final = Float.parseFloat(strs[4]);
                    Student2 Math = new Student2(math_usual, math_final);
                    math_grades = math_usual * 0.4 + math_final * 0.6;
                } else if ("物理".equals(strs[2])) {
                    physic_usual = Float.parseFloat(strs[3]);
                    physic_final = Float.parseFloat(strs[4]);
                    Student2 Physic = new Student2(physic_usual, physic_final);
                    physic_grades = physic_usual * 0.4 + physic_final * 0.6;
                }
            }
            total_grades = (int)chinese_grades + (int)math_grades + (int) physic_grades ;
            usual_grades = (chinese_usual + math_usual + physic_usual)/3;
            final_grades = (chinese_final + math_final + physic_final)/3;
            stu[i] = new Student1(student_idnum,student_name,chinese_grades,math_grades,physic_grades,total_grades,usual_grades,final_grades);
        }
        for(Student1 student : stu){
            System.out.println(student.idnum + " " + student.name + " " + String.format("%.0f",student.total) + " " + String.format("%.2f",student.usual_average) + " " + String.format("%.2f",student.final_average) + " " + String.format("%.2f",student.total/3));
        }
    }
}

这个题目需要注意：

1. 1. 使用合适的输入方法：根据题目要求，在Java中可以使用Scanner类来读取输入。通过创建Scanner对象，可以使用其提供的方法（如nextInt()、nextLine()等）逐行读取输入数据。这题的输入格式我们读取的话，最好选用读取一整行，然后利用分割函数按照空格来分割，将对应的姓名、课程、学号分别进行判断和处理会更加容易。

2. 确定输入数据的格式：在读取输入之前，需要确定输入数据的格式，以便正确地使用适当的方法读取和处理数据。根据题目中给出的输入格式，可以通过调用Scanner对象的相应方法来按格式逐行读取输入。

3. 错误处理和异常情况：在读取输入数据时，可以考虑加入适当的错误处理和异常情况处理机制。例如，可以使用try-catch语句块来捕获输入格式错误、类型转换错误等可能发生的异常，并根据具体情况进行相应的处理和输出错误提示。

4. 循环读取输入数据：根据题目要求，需要依次输入多个学生的成绩信息。可以使用循环结构（如for循环或while循环）来重复读取输入，直到满足停止输入的条件（如输入end后停止）。

5. 数据存储和处理：将读取的数据存储在合适的数据结构中，如学生对象、成绩对象等，以便后续的计算和处理。根据题目要求，可以设计学生类和成绩类，并将读取的数据封装在对应的对象中。

 

第二次作业：题目七（菜单计价）：

public class Main {
    public static void main(String[] args) {
        // 初始化菜谱
        Dish dish1 = new Dish("西红柿炒蛋", 15);
        Dish dish2 = new Dish("清炒土豆丝", 12);
        Dish dish3 = new Dish("麻婆豆腐", 12);
        Dish dish4 = new Dish("油淋生菜", 9);

        Menu menu = new Menu();
        menu.addDish(dish1);
        menu.addDish(dish2);
        menu.addDish(dish3);
        menu.addDish(dish4);

        // 输入订单信息
        Scanner scanner = new Scanner(System.in);
        Order order = new Order();

        String input = scanner.nextLine();
        while (!input.equals("end")) {
            String[] parts = input.split(" ");
            String dishName = parts[0];
            int portion = Integer.parseInt(parts[1]);
            Dish dish = menu.searchDish(dishName);
            if (dish == null) {
                System.out.println(dishName + " does not exist");
            } else {
                Record record = new Record(dish, portion);
                order.addRecord(record);
            }
            input = scanner.nextLine();
        }

        // 计算订单总价并输出
        int totalPrice = order.getTotalPrice();
        System.out.println( totalPrice);
    }
}

这个题目需要注意的点：

1. 输入数据的合法性验证：确保输入的菜名和份额符合要求，菜名必须在菜谱中存在，份额必须是1、2、3中的一个。如果输入的菜名无法识别或者份额不合法，需要进行相应的错误处理。

2. 价格计算的精确性和规则：根据输入的菜名和份额，使用菜谱中对应菜品的基础价格以及份额规则计算菜品的价格。小份菜的价格等于基础价格，中份菜的价格为基础价格乘以1.5，大份菜的价格为基础价格乘以2。对于计算结果可能存在的小数部分，需要按照四舍五入的规则进行处理，最后输出整数结果。

3. 订单的数据存储和计算：使用订单类来保存用户点的所有菜的信息，每一条记录包括菜品和份额。订单类需要提供方法来添加一条菜品记录和计算订单的总价。在添加记录时，需要根据菜名查找对应的菜品信息，如果菜名无法识别，需要进行相应的错误处理。

4. 输出结果的格式：输出订单的总价，以及每份菜的价格。总价为整数结果，每份菜的价格也为整数。如果订单中包含不能识别的菜名，需要在输出总价之前输出对应的错误提示。

5. 异常情况的处理：在处理输入数据和计算过程中，可能会遇到异常情况，比如输入错误、菜名无法识别等。需要进行适当的错误处理，包括错误提示和相关输出。

 

第三次作业：题目二（课程成绩统计程序-1）：

 

这个题的测试点——单门考试课程 单个学生、考核数据与考核方式不匹配、多门课程，单个学生，含错误信息、单个班级，多个学生，多门课程、多个班级，多门课程，多个学生  均未通过，我在题目截至之后又调试了下代码，发现多对多、多对单、单对多方面均有一些问题

//选课
class choose{
    scores score;
    Stu student;
    lessons lesson;
}
//课程
class lessons{
    String lesson_name;
    String course;//必修或选修
    String option;//考察方式
    public void setLesson_name(String lesson_name){
        this.lesson_name = lesson_name;
    }
    public String getLesson_name(){
        return lesson_name;
    }
    public void setCourse(String course){
        this.course = course;
    }
    public String getCourse(){
        return course;
    }
    public void setOption(String option){
        this.option = option;
    }
    public String getOption(){
        return option;
    }
    lessons(String lesson_name , String course , String option){
        setLesson_name(lesson_name);
        setCourse(course);
        setOption(option);
    }
}
//学生
class Stu{
    String idnum;
    String name;
    public void setIdnum(String idnum){
        this.idnum = idnum;
    }
    public String getIdnum(){
        return idnum;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    Stu(String idnum,String name){
        setIdnum(idnum);
        setName(name);
    }
}
//班级
class Classes{
    Stu student;
    String class_num;
    HashMap<String,Stu> Stus;
    Classes(String class_num){
        setClassNum(class_num);
    }
    public void setClassNum(String class_num) {
        this.class_num = class_num;
    }
    public String getClassNum() {
        return class_num;
    }
    public void addStudent(Stu student) {
        Stus.put(student.getIdnum() , student);
    }
}
//成绩
abstract class scores{
    int All_score;
    abstract void getAll_score();
}
//考试成绩
class exam_score extends scores{
    int usual_score;
    int final_score;
    exam_score(int usual_score , int final_score){
        setUsual_score(usual_score);
        setFinal_score(final_score);
    }
    public void setUsual_score(int usual_score) {
        this.usual_score = usual_score;
    }
    public int getUsual_score() {
        return usual_score;
    }
    public void setFinal_score(int final_score) {
        this.final_score = final_score;
    }
    public int getFinal_score() {
        return final_score;
    }
    @Override
    void getAll_score() {
        All_score = (int) (usual_score*0.3+final_score*0.7);
    }
}
//考察成绩
class inspect_score extends scores{
     int finalGrade;
    inspect_score(int finalGrade) {
        setFinalGrade(finalGrade);
    }
    public void setFinalGrade(int finalGrade) {
        this.finalGrade = finalGrade;
    }
    public int getFinalGrade() {
        return finalGrade;
    }
    @Override
    void getAll_score() {
        All_score = finalGrade;
    }
}
/**********此处省略输入、输出类**********/308 
public class Main {
    //throws IOException表示该方法可能会抛出IOException异常，需要通过异常处理机制进行处理
     public static void main(String[] args) throws IOException{
         //InputStreamReader(System.in)用于将字节流转换为字符流，这样我们可以按字符的方式来读取用户输入。
         //BufferedReader则是一个字符缓冲流，它提供了更高效的读取文本的方法，其中readLine()方法可以读取一行用户输入。
         BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
         input inputs = new input();
         inputs.outputs = new output();
         String strs;

         while ((strs = in.readLine()) != null){
             if(strs.equals("end"))  break;
             inputs.getData(strs);
         }

         inputs.outputs.stu_print(inputs.Stus , inputs.Choose );
         inputs.outputs.lesson_print(inputs.Lessons , inputs.Choose );
         inputs.outputs.class_print(inputs.Class , inputs.Choose );
     }
}

本实验旨在对某高校的课程进行考核方式和性质的分析，并计算学生和班级的成绩平均分。实验过程中，我们根据输入的课程信息和成绩信息，按照规定的权重和计算方法计算了各门课程的总成绩，并分析了学生和班级的成绩情况。

通过对输入信息的处理，实验过程中遵循了一些约束条件，包括成绩的整数取值范围、学号和姓名的长度限制等。对于异常情况，比如课程名称不在已输入的课程列表中、输入的成绩数量和考核方式不匹配等，我们进行了相应的错误处理和输出。

在实验结果方面，我们成功计算出了学生所有课程总成绩的平均分，并按照学号由低到高的顺序进行了排序输出。同时，我们也计算了单门课程的平时成绩平均分、期末考试平均分和总成绩平均分，并按照课程名称的字符顺序输出。最后，我们还按班级由低到高的顺序计算了班级所有课程总成绩的平均分。

总的来说，本实验通过输入课程和成绩信息，按照规定的权重和计算方法进行了成绩计算和分析，最终得出了学生和班级的成绩平均分。实验为我们提供了对课程考核和性质的理解，并展示了计算和数据处理的能力。然而在实验过程中，我们也要注意对输入信息的准确性和合法性进行验证，以确保计算结果的可靠性。

在做这个实验的时候需要注意以下几点：

1. 数据的准确性：确保输入的课程信息和成绩信息准确无误，包括学号、姓名、课程名称、平时成绩和期末成绩等。输入错误或者不准确的数据可能导致计算结果的错误或者偏差。

2. 约束条件的遵守：根据实验要求，确保输入数据符合预设的约束条件，比如成绩范围、学号和姓名的长度限制等。如果输入的数据不符合约束条件，需要进行相应的错误处理和输出。

3. 异常情况的处理：在实验过程中，可能会遇到异常情况，比如课程名称不在已输入的课程列表中、输入的成绩数量和考核方式不匹配等。针对这些异常情况，需要进行适当的错误处理和输出，确保结果的准确性和可靠性。

4. 可读性和清晰性：保持代码的可读性和清晰性，采用适当的命名、注释和缩进等方法，以便于他人理解和维护代码。此外，输出结果的格式也应该清晰明了，便于阅读和理解。

5. 测试和验证：在编写实验代码之前，先进行适当的测试和验证，确保代码在不同情况下都能正常运行，并得到正确的结果。可以使用一些示例数据进行测试，以确保代码的正确性

 总结

通过这三次代码大作业，首先，我学习了如何创建和操作类及对象。Java 是一种面向对象的语言，通过定义类和实例化对象，我们可以将问题进行模块化和封装。通过合理地定义类的属性和方法，可以实现数据和操作的高度内聚性。

其次，我熟悉了 Java 的常用数据类型和控制流语句。在实验过程中，我使用了整型、浮点型、字符型等不同的数据类型，以及条件语句和循环语句来控制程序的流程。这些基础知识为我后续的实验操作打下了坚实的基础。另外，我也学习了如何使用 Java 的标准库。Java 的标准库包含了丰富的工具和类，可以帮助我们更高效地完成编程任务。我学习了如何使用 Java 的集合框架来处理数据集合，如何通过输入输出流来进行文件读写操作，以及如何使用异常处理机制来处理程序运行中的错误。

我熟悉了Java的基本语法、常用函数、正则表达式的运用以及面向对象的代码设计思想，同时，我觉得我应该在清晰各个类之间的调用关系上要加强，同时应该要更加熟练的掌握哈希表和动态数组的各种操作。

通过实践，我更加深入地理解了 Java 的特性和用法。