Java面向对象编程——航空器配载与货运管理系统三次作业完整学习总结

Java面向对象编程——航空器配载与货运管理系统三次作业总结

博客作者：胡旺 学号：25201520 课程：Java程序设计

本次作业围绕航空器配载与货运管理系统展开，通过三次迭代作业，逐步巩固Java面向对象编程核心知识点，将课堂理论与实际编程实践相结合，完成了从基础语法应用到复杂业务逻辑实现的逐步提升。现将三次作业集的完成情况、设计思路、心得、改进方向及整体收获总结如下。

一、前言

本次Java面向对象作业共计完成三次作业集，均围绕航空器配载与货运管理系统的迭代开发展开，三次作业层层递进、由浅入深，既注重基础知识点的巩固，也侧重实战能力与业务思维的培养。三次作业的整体设计贴合航空专业特色，将Java编程与航空器载重平衡、货运舱位管理等专业场景结合，打破了纯代码刷题的枯燥模式，让我在完成作业的过程中，不仅掌握编程技能，也初步了解航空货运配载的基础业务逻辑。

从知识点覆盖来看，三次作业覆盖了课堂讲授的面向对象核心内容，包括类的定义与封装、对象的创建与调用、构造方法的使用、ArrayList集合的应用、组合关系的实现、排序算法、数据合法性校验、业务公式计算等，同时逐步引入模块化拆分等实战思维。从题量与难度来看，作业集一以基础语法巩固为主，题量适中、难度较低，重点训练类的封装与简单方法调用；作业集二难度中等，新增集合容器与多类组合关系，重点训练批量数据管理与基础业务逻辑实现；作业集三难度最高，新增专业业务公式、手写冒泡排序、全流程输入校验，重点训练复杂业务逻辑拆解与程序规范性设计。

三次作业累计完成代码量约1500行，涉及实体类、工具类、业务逻辑类共计10余类，每一次作业都是对前一次的优化与拓展，实现了“基础巩固—能力提升—综合应用”的阶梯式学习。在完成作业的过程中，我不仅解决了许多编程错误，更实现了从“会写代码”到“会设计程序、会排查错误、会优化代码”的思维转变，为后续Java学习与课程设计打下了坚实的实践基础。

二、设计与分析

三次作业均围绕航空器配载与货运管理系统展开，每一次作业都在原有版本的基础上进行功能迭代与架构优化，以下结合本人提交的源码、SourceMonitor代码分析报表以及PowerDesigner类图，对三次作业的设计思路、架构结构及核心实现进行详细分析，结合自身编写心得，呈现真实的开发过程。

2.1 作业集一：基础实体类封装与数据展示

2.1.1 源码设计思路

作业集一作为系统的初代版本，核心需求是完成基础货物信息的封装与简单展示，无需实现复杂业务逻辑，重点考察类的封装思想与基础语法应用。本人在本次作业中，设计了两个核心类：Cargo（货物实体类）与Main（程序入口类）。

Cargo类严格遵循面向对象封装原则，将货物编号（id）、货物重量（weight）、货物存放舱位（compartmentId）三个核心属性私有化（private），避免外部类直接篡改属性值；同时编写构造方法，用于初始化货物信息，提供对应的getter方法，用于对外访问私有属性，不提供setter方法，确保货物信息一旦创建，无法随意修改，保障数据安全性。

Main类作为程序入口，负责完成控制台数据录入、Cargo对象创建、属性调用与结果打印。通过Scanner类读取用户输入的货物信息，创建Cargo对象，再通过getter方法获取货物属性，按照题目要求的格式打印输出，实现简单的“输入—存储—输出”流程。

2.1.2 SourceMonitor代码分析

通过SourceMonitor对本人提交的作业集一源码进行分析，得出以下核心数据：代码总行数186行，其中注释28行，注释率15.1%；函数总数8个，其中Cargo类4个（构造方法1个、getter方法3个），Main类4个（主方法1个、数据录入方法1个、对象创建方法1个、打印方法1个）；代码嵌套层级最高为2层（主方法中的for循环与if判断），无复杂嵌套；代码重复率极低，仅打印语句存在少量重复，整体代码可读性良好。

从代码质量来看，本次作业源码严格遵循课堂讲授的编码规范，变量命名规范（采用驼峰命名法），注释清晰，每个方法、每个属性都有对应的注释说明，便于后续阅读与修改；无语法错误、逻辑错误，程序能够正常运行，实现了题目要求的全部基础功能。

2.1.3 PowerDesigner类图分析

通过PowerDesigner绘制本次作业的类图，可清晰看到类之间的关系：本次作业仅包含Cargo与Main两个类，无任何依赖关系、组合关系或关联关系，两个类相互独立。Cargo类包含三个私有属性（id、weight、compartmentId）、一个构造方法和三个getter方法；Main类包含一个主方法和三个辅助方法，负责调用Cargo类的构造方法与getter方法，完成数据处理与输出。

类图结构简单，无复杂关联，符合作业集一“基础封装”的核心要求，也反映出初代系统的局限性——仅能实现单一货物的信息管理，无法批量处理货物数据，无任何业务逻辑判断，拓展性极差。

2.1.4 编写心得

作业集一的编写让我深刻理解了面向对象封装思想的核心意义：封装不仅是将属性私有化，更是为了保障数据安全性，规范代码结构，让程序更加易于维护。在编写过程中，习惯性将属性定义为public，省去getter方法，虽然能够快速实现功能，但违背了封装原则，提交后发现问题并及时整改。

同时，我认识到初代系统的不足：仅能处理单件货物，无法批量管理，且无任何业务逻辑，实用性较低。编程不仅要实现基础功能，还要结合实际业务需求，考虑程序的实用性与拓展性，为后续作业集二的迭代埋下了思考伏笔。

2.2 作业集二：批量数据管理与多类组合关联

2.2.1 源码设计思路

作业集二在作业集一的基础上完成第一次功能迭代，核心需求是实现批量货物管理、货舱与货物的组合关联，以及基础的舱位装载判断。新增CargoCompartment（货舱类），摒弃普通数组，采用上课讲的的ArrayList集合容器，实现批量货物的动态存储与管理。

作业的类结构分为两层：实体数据层与程序入口层。实体数据层包含Cargo（货物类）与CargoCompartment（货舱类），Cargo类在作业集一的基础上进行优化，新增货物名称属性，完善封装；CargoCompartment类封装货舱编号（id）、最大载重（maxWeight）、存放位置（row、col）、已装载货物集合（cargoList）等属性，提供构造方法、货物添加方法、已装载重量统计方法等，实现货舱与货物的组合关联——一个货舱可以包含多个货物，货物无法脱离货舱独立存在，符合现实航空货运的业务逻辑。

程序入口为Main类，负责完成数据录入、货舱与货物对象创建、货物批量装载、数据遍历输出等功能。通过Scanner类读取货舱信息、批量货物信息，创建CargoCompartment对象与多个Cargo对象，调用货舱类的添加方法，将货物装载至对应货舱，同时判断货舱剩余容量是否充足，实现基础的装载校验，最后遍历货舱与货物集合，打印输出所有信息。

2.2.2 SourceMonitor代码分析

通过SourceMonitor分析提交的作业集二源码，核心数据如下：代码总行数372行，注释56行，注释率15.1%；函数总数15个，其中Cargo类5个（构造方法1个、getter方法4个），CargoCompartment类6个（构造方法1个、getter方法4个、货物添加方法1个、重量统计方法1个），Main类4个（主方法1个、数据录入方法1个、对象创建方法1个、打印方法1个）；代码嵌套层级最高为3层（主方法中的for循环嵌套if判断），主要用于批量货物录入与遍历；代码重复率有所降低，通过封装方法减少了重复代码，整体代码模块化程度明显提升。

与作业集一相比，本次作业源码的不同之处在于：批量数据管理，引入ArrayList集合解决数组固定长度的局限性；实现多类组合关联，建立货舱与货物的从属关系；新增业务逻辑判断，实现货舱装载容量校验；代码模块化程度提升，将不同功能拆分至不同方法。

2.2.3 PowerDesigner类图分析

通过PowerDesigner绘制的类图，可清晰梳理本次作业的类关系：CargoCompartment类与Cargo类为组合关系，CargoCompartment类包含一个Cargo类型的ArrayList集合，用于存储多个货物对象；Main类与CargoCompartment类、Cargo类均为依赖关系，Main类通过创建两个类的对象，调用其方法完成业务逻辑。

类图结构清晰，组合关系明确，符合面向对象设计思想。CargoCompartment类作为核心实体，统筹管理多个货物对象，实现了批量货物的装载与管理；Cargo类专注于货物信息的存储，职责单一；Main类仅负责流程调度，不参与具体业务逻辑，体现了模块化设计的思路。

2.2.4 编写心得

作业集二的编写，巩固了ArrayList集合的使用方法，深刻理解了组合关系的设计与实现。在编写过程中，我最初不能准确区分组合关系与普通关联关系，错误地将货物对象创建在Main类中，再传入货舱类，导致货舱与货物的从属关系不明确，经过反复研读题目要求、对照课堂笔记，最终修改为在货舱类内部通过集合管理货物对象，实现了正确的组合关系。

我也学会了模块化拆分思想，将数据存储、业务判断、数据遍历等功能拆分至不同类、不同方法，让代码逻辑更加清晰，后期修改维护更加便捷。例如，将货舱已装载重量的统计功能封装为独立方法，避免在主方法中重复编写遍历累加代码，提升了代码的复用性。我认识到集合容器在批量数据管理中的优势，ArrayList的动态增删功能完美适配实际业务中货物数量不固定的场景。

本次作业存在不足：未独立拆分工具类，所有数据合法性判断、重量统计等逻辑零散写在主方法或实体类中，代码冗余度较高；未引入排序算法，批量货物仅能按照录入顺序输出，无法按照业务需求有序展示；业务逻辑较为简单，仅实现了基础的装载校验，未考虑更多异常场景。

2.3 作业集三：复杂业务实现与程序鲁棒性优化

2.3.1 源码设计思路

作业集三，核心需求是实现旅客与行李的管理、航空器载重平衡计算、手写冒泡排序、全流程输入校验。

实体数据模块包含5个核心类：Luggage（行李类）、Passenger（旅客类）、Cargo（货物类）、CargoCompartment（货舱类）、Flight（航班类）。Luggage类封装行李重量属性，Passenger类与Luggage类为组合关系，旅客对象内部创建行李对象，外部仅能传入行李重量，无法直接修改行李信息；Cargo类与CargoCompartment类在作业集二的基础上优化，完善属性与方法；Flight类作为全局统筹类，管理前后两个货舱对象、全体旅客对象，实现所有实体数据的汇总，为后续业务计算提供数据支撑。

工具模块包含3个核心类：InputValidator（输入校验工具类）、LoadSort（排序工具类）、WeightBalanceCalculator（载重平衡计算工具类）。InputValidator类负责全程序输入数据的合法性校验，包括负数拦截、数值范围校验，一旦检测到非法数据，按照题目要求提示并终止程序；LoadSort类内部纯手写标准冒泡排序算法，按照货物编号升序排序，禁用任何系统自带排序API；WeightBalanceCalculator类封装航空载重平衡专业公式，完成旅客总重量、旅客力矩、货物总重量、货物总力矩、全机总重量、全机总力矩、实际重心、MAC重心百分比的计算，最终依据25%-38%的安全范围，判定配平安全等级。

程序入口为Main类，负责完成全流程调度：读取航班信息、货舱信息、旅客信息、货物信息，创建各类对象，调用工具类完成输入校验、货物排序、载重平衡计算，最终打印输出载重平衡舱单与配平评估结果。

2.3.2 SourceMonitor代码分析

通过SourceMonitor分析本人提交的作业集三源码，核心数据如下：代码总行数948行，注释142行，注释率15.0%；函数总数32个，涵盖实体类的构造方法、getter方法，工具类的校验方法、排序方法、计算方法，以及Main类的调度方法；代码嵌套层级最高为4层（冒泡排序的双重for循环嵌套if判断、计算方法中的for循环嵌套），逻辑清晰，无过度嵌套；代码重复率极低，工具类的方法可重复调用，极大减少了冗余代码；代码可读性与可维护性大幅提升，每类、每个方法都有清晰的注释，职责明确。

本次作业源码的优势在于：类结构规范，职责划分清晰，实现数据与业务的完全解耦；全流程拦截非法输入、超限装载等异常场景；引入专业业务公式，实现编程与专业知识的融合；底层排序算法，夯实了基础编程能力；代码复用性高，工具类可灵活调用，便于后续功能拓展。

2.3.3 PowerDesigner类图分析

通过PowerDesigner绘制的完整类图，可清晰梳理所有类之间的关系：Passenger类与Luggage类为组合关系，Passenger类包含一个Luggage对象；Flight类与CargoCompartment类、Passenger类均为聚合关系，Flight类包含CargoCompartment类型与Passenger类型的ArrayList集合；CargoCompartment类与Cargo类为组合关系，CargoCompartment类包含Cargo类型的ArrayList集合；InputValidator类、LoadSort类、WeightBalanceCalculator类与所有实体类均为依赖关系，通过传入实体对象，完成校验、排序、计算功能；Main类与所有类均为依赖关系，负责全局调度。

类图结构完整，关系清晰，完全符合题目约束：无任何继承与多态结构，仅依靠组合关系、聚合关系、依赖关系实现类交互；所有类各司其职，实体类负责存储数据，工具类负责实现通用功能，业务类负责完成专业计算，程序入口类负责调度，体现了面向对象设计的核心思想。

2.3.4 编写心得

作业集三最具挑战性、收获最大的部分。通过本次作业，我不仅熟练掌握了ArrayList集合的高级使用方法、手写冒泡排序的底层实现，更深刻理解了单一职责原则、依赖注入思想在实际编程中的应用。在编写过程中，我学会将复杂业务逻辑拆解为多个简单模块，逐一实现、逐步整合，避免了盲目堆砌代码导致的逻辑混乱。

一款合格的业务程序，不仅要实现正确的功能，还要能够应对各类异常场景。例如，在输入校验环节，我仅拦截了负数输入，遗漏了货物分配数量p的范围校验（0≤p≤m），导致程序在非法输入时崩溃，经过多次测试与修改，补充了范围校验，实现了所有异常场景的精准拦截。

此外，本次作业也让我实现了跨学科知识的融合，将Java编程与航空载重平衡专业知识结合，让我意识到编程语言并非孤立的理论，而是服务于实际业务的工具。同时，我也认识到自身的不足：代码优化能力有待提升，批量数据遍历方式较为单一；工具类的通用方法未进一步抽象整合；控制台输出格式固定，无法灵活调整，这些都是后续优化的重点方向。

三、心得

在完成三次作业的全过程中，我遇到了大量语法错误、逻辑错误、业务理解错误、格式规范错误，每一处错误都经过反复调试、对照题目要求核对、参考测试结果排查解决。以下结合具体代码、测试数据、运行流程，详实总结本次实训的踩坑经历与心得，杜绝空泛表述，全部以实际开发问题为依据。

3.1 基础语法与编码习惯类

这类错误主要出现在作业集一、作业集二的初期编写阶段，核心原因是基础语法不熟练、编码习惯不规范，具体如下：

踩坑1：封装思想理解不到位，属性定义违规。作业集一初期，我习惯性将Cargo类的属性定义为public，省去getter方法，认为这样编写更便捷，能够直接访问属性、简化代码。提交作业后，发现不符合面向对象封装要求，被判定格式不规范。最初的Cargo类代码如下：

class Cargo {
public int id;
public double weight;
public String compartmentId;
public Cargo(int id, double weight, String compartmentId) {
this.id = id;
this.weight = weight;
this.compartmentId = compartmentId;
}
}

整改后，将所有属性改为private，添加对应的getter方法，删除不必要的setter方法，确保数据安全性，整改后的代码如下：

class Cargo {
private int id;
private double weight;
private String compartmentId;
public Cargo(int id, double weight, String compartmentId) {
this.id = id;
this.weight = weight;
this.compartmentId = compartmentId;
}
public int getId() {
return id;
}
public double getWeight() {
return weight;
}
public String getCompartmentId() {
return compartmentId;
}
}

心得：封装是面向对象编程的基础，无论业务逻辑简单与否，都必须养成“属性私有、提供getter/setter、构造方法初始化”的编码习惯，不仅能保障数据安全性，还能规范代码结构，便于后续维护。

2：ArrayList集合使用不熟练，出现下标越界错误。作业集二在批量遍历货物集合时，我错误地使用了固定长度的for循环，未结合集合的size()方法获取实际长度，导致当货物数量少于循环次数时，出现ArrayIndexOutOfBoundsException异常。例如，最初的遍历代码如下：

for (int i = 0; i < 10; i++) {
Cargo cargo = cargoList.get(i);
System.out.println(cargo.getId() + "," + cargo.getWeight());
}

整改后，结合cargoList.size()获取集合实际长度，避免下标越界，整改后的代码如下：

for (int i = 0; i < cargoList.size(); i++) {
Cargo cargo = cargoList.get(i);
System.out.println(cargo.getId() + "," + cargo.getWeight());
}

心得：使用ArrayList集合时，务必结合size()方法获取实际元素数量，避免使用固定长度的循环，同时注意集合的增删操作对下标位置的影响，防止出现下标越界错误。

3：控制台输入读取方式错误，出现换行符残留。作业集二、作业集三初期，我混合使用nextInt()与nextLine()读取输入，导致nextLine()读取到换行符，出现字符串读取为空的隐形BUG。例如，读取航班号与旅客人数时，代码如下：

Scanner sc = new Scanner(System.in);
System.out.println("请输入航班号：");
String flightNo = sc.nextLine();
System.out.println("请输入旅客人数：");
int personNum = sc.nextInt();
System.out.println("请输入旅客行李重量：");
double bagWeight = sc.nextLine(); // 此处读取到换行符，无法获取正确输入

整改后，统一使用next()方法读取简单字符串与数值，规避换行符残留问题，整改后的代码如下：

Scanner sc = new Scanner(System.in);
System.out.println("请输入航班号：");
String flightNo = sc.next();
System.out.println("请输入旅客人数：");
int personNum = sc.nextInt();
System.out.println("请输入旅客行李重量：");
double bagWeight = sc.nextDouble();

心得：控制台输入读取时，尽量避免混合使用nextInt()与nextLine()，若必须混合使用，需在nextInt()后添加sc.nextLine()吸收换行符，避免出现隐形BUG，确保输入流程顺畅。

 3.2 类关系与业务逻辑类

这类错误主要出现在作业集二、作业集三，核心原因是对组合关系、聚合关系理解不透彻，业务逻辑梳理不清晰，具体如下：

1：组合关系实现错误，违背题目要求。作业集三要求旅客与行李为组合关系，行李对象必须在旅客构造方法内部创建，外部无法直接创建行李对象。我最初错误地在Main类中创建行李对象，再传入旅客构造方法，代码如下：


Luggage luggage = new Luggage(15.0);
Passenger passenger = new Passenger(luggage);


class Passenger {
    private Luggage luggage;
    public Passenger(Luggage luggage) {
        this.luggage = luggage;
    }
}

这种写法导致行李对象可以脱离旅客独立存在，违背了组合关系“整体与部分不可分离”的原则，提交后判定结构错误。整改后，将行李对象的创建封装在旅客构造方法内部，外部仅传入行李重量，整改后的代码如下：


Passenger passenger = new Passenger(15.0);


class Passenger {
    private Luggage luggage;
    private static final double BASE_WEIGHT = 75.0;
    public Passenger(double bagWeight) {
        this.luggage = new Luggage(bagWeight); // 内部创建行李对象
    }
    public double getTotalWeight() {
        return BASE_WEIGHT + luggage.getWeight();
    }
}


心得：组合关系与普通关联关系的核心区别的是“整体与部分不可分离”，在设计类关系时，需结合实际业务逻辑，明确实体之间的从属关系，避免出现类关系设计错误。
2：排序算法违规与排序规则错误。作业集三要求手写冒泡排序，禁用系统自带排序方法，且按照货物编号升序排序。我最初习惯性使用Collections.sort()方法排序，代码如下：

Collections.sort(cargoList, new Comparator<Cargo>() {
    @Override
    public int compare(Cargo o1, Cargo o2) {
        return o1.getId() - o2.getId();
    }
});

public void bubbleSort(ArrayList<Cargo> list) {
    int len = list.size();
    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - 1 - i; j++) {
            Cargo a = list.get(j);
            Cargo b = list.get(j + 1);
            if (a.getId() > b.getId()) { // 编号小的在前，升序排序
                list.set(j, b);
                list.set(j + 1, a);
            }
        }
    }
}

心得：在完成作业时，必须严格遵守题目给出的硬性约束，尤其是算法使用、类关系设计等要求，不能图便捷使用超出要求的API；同时，要仔细阅读题目要求，明确业务规则（如排序规则），避免因理解偏差导致错误。

 3.3 业务计算与程序鲁棒性类

这类错误主要出现在作业集三，核心原因是对专业业务公式理解不透彻、异常场景考虑不全面，具体如下：

1：载重平衡计算公式错误，导致配平判定偏差。作业集三的核心业务是航空器载重平衡计算，涉及多个专业公式，我最初因混淆MAC前缘距离（15.0）与MAC长度（5.0），颠倒了重心百分比的计算公式，导致计算结果错误，安全场景判定为危险，危险场景判定为安全。例如，最初的错误公式代码如下：

double macPercent = ((Flight.MAC_LEN - (cg - Flight.MAC_START)) / Flight.MAC_START) * 100;

对照题目给出的标准公式（重心百分比=（实际重心- MAC前缘距离）/ MAC长度 × 100），整改后的代码如下：

double macPercent = ((cg - Flight.MAC_START) / Flight.MAC_LEN) * 100.0;


心得：对于专业业务公式，必须逐字逐句对照题目要求，明确每个参数的含义，分步编写计算代码，分步打印中间结果（如旅客力矩、货物力矩、全机总力矩），对照标准样例逐一核对，避免因公式错误导致整体业务逻辑偏差。

2：输入校验不全面，遗漏异常场景。作业集三初期，我仅完成了负数输入的拦截，遗漏了货物分配数量p的范围校验（0≤p≤m），当输入p<0或p>m时，程序无任何提示直接崩溃；同时，货舱装载超限的提示语句格式与题目要求不符，浮点数值保留小数位数不规范。例如，最初的提示语句如下：

System.out.println("警告：前舱容量不足，当前载重" + front.getNowWeight() + "kg，最大载重" + front.getMaxWeight() + "kg");


整改后，补充了p的范围校验，修改提示语句格式，统一浮点数值保留1位小数，整改后的代码如下：


if (frontCargoNum < 0 || frontCargoNum > totalCargo) {
    System.out.println("输入必须在 0 到 " + totalCargo + " 之间！");
    sc.close();
    return;
}


System.out.printf("!!! 警告：[1]剩余容量不足(当前载重%.1f/%.1fkg)，请重新分配或减轻重量！%n",front.getNowWeight(),front.getMaxWeight());


心得：编写程序时，必须全面考虑各类异常场景，包括非法输入、超限装载、数值范围错误等，同时严格按照题目要求的格式输出提示信息，避免因格式不规范导致测试点不通过。

 3.4 整体总结

通过三次作业的经历，我总结出以下核心心得：第一，基础语法与编码习惯是编写正确代码的前提，必须扎实掌握课堂讲授的知识点，养成规范的编码习惯，避免因基础错误影响整体作业进度；第二，类关系与业务逻辑的梳理是面向对象编程的核心，拿到需求后，应先绘制类图、梳理业务流程，再动手编写代码，避免盲目堆砌代码导致逻辑混乱；第三，专业业务公式与题目约束必须严格遵守，不能凭主观判断修改公式或使用超出要求的API；第四，程序鲁棒性不容忽视，要全面考虑各类异常场景，实现全流程异常拦截，确保程序稳定运行；第五，错误排查能力是实战编程的重要能力，遇到错误时，不要急于修改，应通过分步调试、打印中间结果、对照题目要求等方式，精准定位错误原因，逐步整改。

 四、改进建议

结合三次作业的完成情况、现存代码短板、业务拓展需求以及Java面向对象编程优化思想，从代码简洁性、架构拓展性、功能丰富性、运行高效性四个维度，给出具备落地性、可持续性的改进建议，所有建议均贴合课堂所学知识，无超纲技术内容，可直接应用于后续代码优化。

 4.1 代码基础写法优化建议

4.1.1 统一全局常量管理。目前，三次作业中所有固定业务常量（如空机重量40000.0、标准旅客体重75.0、力臂数值、MAC相关参数等），分散定义在各个实体类内部，后续若需修改参数，需遍历全程序查找修改，维护效率较低。建议单独创建全局常量工具类（如ConstantUtil），将所有固定常量集中声明管理，例如：

class ConstantUtil {
    // 空机相关常量
    public static final double EMPTY_WEIGHT = 40000.0;
    public static final double EMPTY_ARM = 16.25;
    public static final double EMPTY_ARM_SHOW = 16.3;
    // 旅客相关常量
    public static final double PASSENGER_BASE_WEIGHT = 75.0;
    public static final double PASSENGER_ARM = 18.0;
    // MAC相关常量
    public static final double MAC_START = 15.0;
    public static final double MAC_LEN = 5.0;
    // 安全重心范围
    public static final double CG_MIN = 25.0;
    public static final double CG_MAX = 38.0;
}

这样，后续修改任何常量，仅需修改ConstantUtil类一处代码，提升代码维护效率，同时避免常量定义混乱。

4.1.2 封装通用工具方法，减少代码冗余。当前程序中，重量统计、集合遍历、数值格式化等重复逻辑在多个类中重复编写，例如，货舱类、航班类中均有重量统计方法，代码冗余度较高。建议在通用工具类（如CommonUtil）中，封装静态通用方法，供全程序调用，例如：

class CommonUtil {
    // 批量货物重量统计
    public static double calculateCargoTotalWeight(ArrayList<Cargo> cargoList) {
        double sum = 0.0;
        for (int i = 0; i < cargoList.size(); i++) {
            sum += cargoList.get(i).getWeight();
        }
        return sum;
    }
    // 浮点数值保留1位小数
    public static double formatDouble(double num) {
        return Math.round(num * 10) / 10.0;
    }
}

这样，所有需要统计货物重量、格式化数值的场景，直接调用通用方法即可，减少重复代码，提升代码简洁性与复用性。

 4.2 程序架构设计优化建议

4.2.1 彻底拆分业务层与数据层。当前作业集三虽然实现了类的职责拆分，但货舱类内部仍保留装载判断业务逻辑，违背了单一职责原则。建议将所有业务逻辑（如装载判断、货物分配）迁移至独立业务处理类（如CargoLoadService），实体类仅负责存储数据，不参与任何业务逻辑，实现数据与业务的完全解耦。例如，将货舱装载判断方法迁移至业务类：

class CargoLoadService {
    // 货物装载判断
    public static boolean loadCargo(CargoCompartment compartment, Cargo cargo) {
        double currentWeight = CommonUtil.calculateCargoTotalWeight(compartment.getCargoList());
        if (currentWeight + cargo.getWeight() <= compartment.getMaxWeight()) {
            compartment.getCargoList().add(cargo);
            return true;
        }
        return false;
    }
}

这样，后续修改装载判断规则时，仅需修改业务类，不影响货舱实体类的结构，提升代码的可维护性与拓展性。

4.2.2 优化双舱业务逻辑，消除重复代码。当前程序中，前货舱与后货舱的业务逻辑（如力矩计算、装载判断）大量重复，仅力臂参数存在差异。建议编写通用货舱业务方法，通过传入货舱编号，自动匹配对应力臂数值，消除重复代码。例如，在载重平衡计算工具类中，优化力矩计算方法：

// 优化前（重复代码）
if (cmp.getCid().equals("1")) {
    cargoMoment += w * Flight.FRONT_ARM;
} else {
    cargoMoment += w * Flight.REAR_ARM;
}

public double calculateCargoMoment(CargoCompartment compartment) {
    double weight = CommonUtil.calculateCargoTotalWeight(compartment.getCargoList());
    double arm = compartment.getCid().equals("1") ? ConstantUtil.FRONT_ARM : ConstantUtil.REAR_ARM;
    return weight * arm;
}

 4.3 功能层面可持续拓展建议

4.3.1 新增货物修改与删除功能。当前系统仅支持货物新增装载，不支持已装载货物的修改与删除，贴合真实航空货运临时调整装载计划的业务需求，可新增货物删除、重量修改方法。例如，在货舱业务类中，新增删除方法：

public static boolean deleteCargo(CargoCompartment compartment, int cargoId) {
    ArrayList<Cargo> cargoList = compartment.getCargoList();
    for (int i = 0; i < cargoList.size(); i++) {
        if (cargoList.get(i).getId() == cargoId) {
            cargoList.remove(i);
            return true;
        }
    }
    return false;
}

4.3.2 新增多航班管理功能。当前程序仅支持单次单一航班的配载计算，实用性受限。可使用ArrayList集合存储多个航班对象，实现多航班数据批量录入、批量计算、指定航班查询功能，提升程序的实用性。例如，在Main类中，新增多航班管理逻辑：

ArrayList<Flight> flightList = new ArrayList<>();
// 批量添加航班
flightList.add(new Flight("CA1234"));
flightList.add(new Flight("MU5678"));
// 批量计算配平
WeightBalanceCalculator calculator = new WeightBalanceCalculator();
for (Flight flight : flightList) {
    calculator.calc(flight);
}

4.3.3 优化配平结果输出格式。当前程序仅支持控制台文字输出，可优化舱单排版，划分更清晰的板块，同时增加配平结果备注提示，针对接近安全临界值（如MAC百分比接近25%或38%）的装载方案，给出预警提示，提升程序的业务实用性。

 4.4 程序运行与校验优化建议

4.4.1 丰富异常数据拦截场景。当前程序仅完成基础的异常拦截，可新增更多真实业务异常场景，例如：货物重量为0、旅客行李重量超出合理范围（如大于50kg）、货物编号重复录入、航班号格式不规范等，进一步提升程序健壮性。

4.4.2 优化手写冒泡排序效率。当前手写冒泡排序仅完成基础排序功能，可加入优化逻辑：当一轮遍历未发生任何元素交换时，说明集合已有序，直接终止排序循环，减少不必要的循环执行，提升排序效率。优化后的冒泡排序代码如下：

public void bubbleSort(ArrayList<Cargo> list) {
    int len = list.size();
    boolean isSorted; // 标记是否已有序
    for (int i = 0; i < len - 1; i++) {
        isSorted = true;
        for (int j = 0; j < len - 1 - i; j++) {
            Cargo a = list.get(j);
            Cargo b = list.get(j + 1);
            if (a.getId() > b.getId()) {
                list.set(j, b);
                list.set(j + 1, a);
                isSorted = false; // 发生交换，说明未有序
            }
        }
        if (isSorted) {
            break; // 未发生交换，直接终止排序
        }
    }
}

 五、总结

本次Java面向对象实训的三次迭代作业，是我从理论学习走向实战应用的重要历练。通过完成航空器配载与货运管理系统的三次迭代开发，我不仅巩固了Java面向对象的核心知识点，更提升了实战编程能力、业务逻辑梳理能力、错误排查能力，实现了从“会写代码”到“会设计程序、会优化程序、会解决问题”的思维转变，同时也收获了跨学科知识融合的体验，将Java编程与航空专业知识结合，深刻认识到编程语言在实际行业中的应用价值。

 5.1 个人学习收获

在知识点掌握层面，我彻底吃透了类的定义与封装、对象的创建与调用、构造方法的使用等基础内容；熟练掌握了ArrayList集合的动态管理方法，能够独立完成批量对象的增删、遍历、统计；熟练掌握了手写冒泡排序的底层实现思路，脱离系统内置API，夯实了基础编程能力；深刻理解了组合关系、聚合关系、依赖关系的设计与实现，能够结合实际业务逻辑，设计合理的类结构；熟练运用专业公式完成复杂业务计算，实现了编程与专业知识的融合；同时建立了程序鲁棒性思维，养成了全面考虑异常场景、规范编码的良好习惯。

在实战能力层面，我学会了模块化拆分业务逻辑，将复杂需求拆解为多个简单模块，逐一实现、逐步整合；具备了基础的软件迭代开发思维，能够在原有版本的基础上，增量式新增功能、优化架构、修复漏洞；提升了代码调试与错误排查能力，能够快速定位各类错误，结合测试数据与题目要求，逐步整改完善；同时养成了规范的编码习惯，注重代码的可读性、可维护性与复用性，为后续Java学习与课程设计打下了坚实的基础。

在思维层面，我彻底摒弃了面向过程的流水式编程思维，建立了面向对象的模块化设计思维，拿到业务需求后，能够先梳理实体、绘制类图、规划业务流程，再动手编写代码；同时培养了严谨的业务思维，注重细节，严格遵守题目约束与业务规范，避免因细节错误影响整体作业质量。

 5.2 自身不足与后续学习计划

通过本次实训，我也清晰认清了自身存在的不足：第一，类架构设计能力有待提升，面对体量更大、逻辑更复杂的项目，梳理类关系、划分功能模块的速度较慢，缺乏整体设计思维；第二，代码优化能力不足，编写完成基础功能后，很难第一时间发现代码冗余、架构不合理等潜在问题，对代码的简洁性、高效性考虑不够全面；第三，流程图、类图的绘制能力较为薄弱，无法快速绘制出规范、清晰的类图与业务流程图，不利于业务逻辑的梳理；第四，对课堂讲授的拓展性知识点（如静态方法、工具类设计）运用不够熟练，后续需要加强练习。

针对以上不足，我制定了后续学习计划：第一，加强类架构设计练习，多尝试独立设计小型业务程序，绘制规范的类图与流程图，培养整体设计思维；第二，注重代码优化，完成基础功能后，主动排查冗余代码，学习常用的代码优化技巧，提升代码的简洁性与高效性；第三，加强流程图、类图绘制练习，熟练使用PowerDesigner等工具，提升可视化设计能力；第四，巩固课堂拓展知识点，多做综合性编程练习，将所学知识灵活运用到实际编程中；第五，主动关注Java编程的行业规范与最佳实践，养成更好的编码习惯，提升自身综合编程素养。

 5.3 课程、作业与实训组织方式的改进建议

结合本次三次作业的完成体验、日常课堂授课与上机实训的学习体验，在不提及课程难度的前提下，从授课形式、作业布置、上机实训、课后辅导四个方面，提出合理化改进建议，助力课程教学质量进一步提升。

在课堂理论授课方面，当前课堂知识点讲解条理清晰、重难点突出，授课节奏合理，建议后续在讲解面向对象架构设计、多类关系、底层算法等重难点内容时，增加更多贴合航空专业特色的小型案例演示，以航空器、货运舱位、旅客行李等相关实体作为案例，让理论知识点与专业场景结合更加紧密，提升课堂学习兴趣与知识点理解效率；同时，对于手写排序、公式换算等实操性极强的知识点，建议课堂上带领同学们同步手写核心代码，分步演示编写过程，强化课堂实操记忆，避免“听懂但不会写”的问题。

在作业布置方面，本次三次迭代作业的增量式布置模式十分科学，由浅入深、逐步提升，建议后续布置迭代类作业时，提前发布完整的项目开发路线图，明确每一次作业的迭代目标、新增功能、核心要求，让同学们在完成每一次阶段性作业时，都能清晰知晓当前开发进度与后续方向，建立整体开发思维，避免盲目编写代码；同时，建议在发布作业题目时，将硬性约束（如禁用API、类关系要求）、输出格式标准、测试样例要点进行集中汇总标注，减少同学们因遗漏规则导致的扣分。

在线上机实训方面，上机实操能够有效巩固课堂理论知识，建议后续上机实验课堂中，增加现场错误排查实训环节，由教师整理同学们高频出现的典型错误代码，让同学们现场独立排查BUG、修改代码，针对性提升代码调试能力；同时，划分分层练习任务，设置基础巩固任务、能力提升任务、拓展创新任务，适配不同学习进度同学的需求，让基础薄弱的同学夯实基础，学有余力的同学拓展提升；此外，建议增加小型小组合作实训环节，鼓励同学们在不共享源码的前提下，互相交流设计思路、排查错误，提升团队协作能力。

在课后辅导方面，当前课后答疑渠道通畅，能够及时解决同学们的问题，建议后续定期整理三次作业的高频错误汇总文档、标准类图参考、核心流程图梳理资料，统一分享至课程学习群，方便同学们课后自主复盘、避免同类错误重复出现；同时，建议定期组织小型课后编程交流活动，邀请学习优秀的同学分享编程思路与学习方法，营造良好的课后学习氛围；此外，建议针对重难点知识点，发布补充练习题目，让同学们课后自主练习，进一步巩固所学知识。

 5.4 整体展望

本次三次迭代作业的实训，让我深刻认识到Java面向对象编程的实用性与趣味性，也让我坚定了继续学习的决心。在今后的学习中，我会将本次实训积累的编码习惯、设计思维、错误排查经验，全面应用到后续的课程学习、课程设计与编程练习中，重点补强自身不足，不断提升实战编程能力与综合素养。同时，我也会主动将编程知识与航空专业知识深度融合，探索更多专业场景下的编程应用，努力将书本理论知识转化为自身的实战能力，为后续的毕业设计、职业发展筑牢坚实的基础，努力成为一名具备扎实编程能力、严谨思维的复合型学习者。