企业官网建设流程全解析

软件工程这门课，面向对象部分通常是一学期里作业最多、分值最重、也最让同学头疼的一块。翻来覆去无非就是那几类题：概念辨析、UML类图画图、代码填空、程序改错、小系统设计。很多同学拿到作业第一反应是“我不会画”“我看不懂题目在问什么”，但其实面向对象作业的题型非常固定，出题逻辑也有规律可循，练熟之后拿高分并不难。

这篇文章把我带过的课程里、以及平时帮人改作业时常见的面向对象作业题目整理了一遍，按题型分类，逐个给出参考答案和解题分析，目标很直接：让你看完之后，再碰到类似作业能自己下手写，而不是对着题目发呆。内容适合正在上软件工程课程的同学、准备期末复习的学生，也适合刚入行想补一补面向对象基本功的开发者。

我会先从“老师为什么出这些题”说起，再梳理高频考点，然后进入核心部分——典型题目和参考答案逐题拆解。最后补上实操中容易踩的坑和老师评分的关注点。这篇内容比较长，建议先收藏再慢慢看，最好配合自己的课程教材一起用。

1. 题型设计与考察逻辑拆解

很多同学拿到作业就急着翻书、查答案，但我建议先停下来想一想：老师到底在考你什么？面向对象部分的作业题，表面上看是让你写代码、画图、答概念，本质上都是在验证三件事：第一，你是否理解面向对象三大特性——封装、继承、多态；第二，你是否能把现实需求抽象成类和对象；第三，你是否具备用UML表达设计、用代码落地设计的能力。

1.1 出题规律：四个固定套路

我梳理了常见的作业题，发现几乎所有的题目都跑不出下面四个套路：

• 概念辨析题：考术语的准确性。比如“封装和抽象的区别”“重载和重写的区别”“继承和组合的区别”。这类题分值不高但几乎必出，主要看你对概念的理解是不是“精准”，而不是“大概知道”。
• UML建模题：给一段文字描述，让你画出类图。这种题考察的是抽象能力和建模能力。老师看的是类是否找得全、关系是否画得对、属性方法是否标得合理。
• 代码设计题：要求用面向对象语言（一般是Java或C++）实现某个小场景，比如“用多态实现动物叫”“用抽象类设计一个图形面积计算器”。这类题综合考察三大特性和语法基本功。
• 程序改错题：给一段有明显问题的代码，让你指出错误并改正。很多是故意把构造方法写错、把继承的访问权限搞错、把方法重写写成重载。这种题最容易丢分，因为它要求你不仅看得懂代码，还得知道“为什么错”。

1.2 分值分布与复习优先级

以我看到的作业和试卷来看，分值占比大概是这样的：

• 概念题约20%到25%，属于送分题，背熟就行；
• UML类图题约25%到30%，需要专门练画图规范；
• 代码设计题约30%到35%，是拉开差距的关键；
• 改错题约15%到20%，考察细节敏感度，也是很多人容易失分的地方。

从这个分布能看出，想拿高分，重点应该放在代码设计题和UML图上。概念题靠短期记忆可以突击，但代码设计能力短时间很难速成，所以平时作业一定要自己动手写，不要只当“搬运工”。

提示：如果时间有限，复习优先级建议是“代码设计题 > UML类图题 > 改错题 > 概念题”。代码设计题里又优先练多态和接口相关的场景，因为这是面向对象部分的核心考点。

2. 核心知识点梳理与高频考点清单

在开始做题之前，先把面向对象部分最核心的知识点过一遍。下面这些内容是几乎所有作业题的“底层密码”，掌握了这些，再去看题目会轻松很多。

2.1 类与对象：一切的基础

类是抽象的概念，对象是具体的实体。举个简单例子，“学生”是一个类，定义了学号、姓名、成绩这些属性和选课、考试这些方法；而“张三”就是学生类的一个对象，它有具体的学号、姓名和成绩。作业题里经常出现的经典问法是：“类和对象的区别是什么？请举例说明。”很多人会背定义，但不会举例子。我建议准备两个通用例子：一个是“学生类与张三”，另一个是“汽车类与某辆具体的车”。例子要体现“类描述共同特征，对象拥有具体的属性值”，这样答题基本不会丢分。

2.2 封装：不是“把变量私有化”这么简单

封装的核心是“信息隐藏”，但不是让你把所有属性都设成private然后就算完事。正确的做法是：属性私有化，对外提供public的getter和setter方法，在方法里可以加入合法性校验。很多作业题会让你设计一个类并“体现出封装性”，如果只写了private却没有任何访问方法，老师一眼就能看出你不理解封装。答题时最好加上“在setter方法中对参数进行校验”的细节，这是得分亮点。

我批改作业时见过一个很普遍的问题：同学把属性全部写成public，理由是“这样写代码简单”。这完全偏离了封装的目的。封装的本质是控制外部对内部状态的访问，如果你把属性全公开，类的状态可以被随意篡改，后面维护时很容易出bug。正确写法虽然代码多一点，但换来的稳定性和可维护性是非常值得的。

2.3 继承与多态：最容易混淆的一组概念

先说继承，它表达的是“is-a”关系。比如“猫”继承“动物”，猫是一种动物。继承要抓住三个要点：子类可以复用父类的属性和方法；子类可以扩展自己的属性和方法；子类可以重写父类的方法。作业里的常见错误是把“has-a”关系也当成继承，比如“汽车”和“发动机”——发动机不是一种汽车，这是组合关系，不是继承。

再说多态，它的前提是继承或接口实现，核心表现是“父类引用指向子类对象，调用同名方法时表现出不同行为”。用一句话解释：“同一个消息，不同的对象接收后产生不同动作。”作业题里最常见的例子就是“动物叫”：定义动物父类的叫方法，让猫、狗各自重写，然后通过父类引用调用。这个例子要练到闭着眼都能写出来，因为它几乎出现在每一份作业里。

2.4 重载与重写：一字之差，千差万别

这两个概念在选择题和简答题里出现频率很高，也是最容易混淆的两个。

• 重载：同一个类里，方法名相同但参数列表（参数个数、类型、顺序）不同。它跟返回值无关，仅仅改变返回值不算重载。
• 重写：子类对父类的方法重新实现，方法名、参数列表、返回值都必须和父类方法一致，访问权限不能比父类更严格。

记忆技巧：重载是“同一屋檐下（同类中）的同名不同参”；重写是“两代人（父与子）的同名同参”。作业里经常给一段代码让你判断是重载还是重写，甚至故意设计一个“返回值不同但参数相同”的方法来误导你——注意，这既不构成重载也不构成重写，属于代码错误。

2.5 抽象类与接口：方案选择题的核心考点

抽象类用abstract关键字修饰，它可以有抽象方法也可以有普通方法，子类必须实现所有抽象方法。接口在Java 8之后可以有默认方法和静态方法，但核心思想是“规定行为契约”——接口定义“能做什么”，实现类负责“怎么做”。

作业题里出现频率极高的一个问法：“什么时候用抽象类，什么时候用接口？”我的答题思路分三点：如果多个类之间有明显的继承关系且共享状态（属性），用抽象类；如果只是要规定一组行为、不关心类的继承体系，用接口；如果既需要共享代码又需要行为契约，可以结合使用。答题时如果能举一个“图形面积计算”的例子——形状用抽象类、可打印用接口——得分会高很多。

2.6 UML类图：作业里的“压轴题”

UML类图几乎是每份作业的必考题，而且分值不低。很多同学一看到画图就头皮发麻，其实只要掌握六类关系和常见的类图表达符号就够了。类用矩形表示，上面写类名，中间写属性，下面写方法。关系线有六种：继承用带空心三角的实线箭头，实现用带空心三角的虚线箭头，组合用带实心菱形的实线，聚合用带空心菱形的实线，关联用普通实线，依赖用带普通箭头的虚线。这些符号必须记牢，因为画错符号比类找漏了还要致命。

3. 典型作业题目及参考答案逐题拆解

下面进入正题。我把常见的作业题精选了十道，覆盖了概念、UML、代码设计和改错四类。每一题都给出标准参考答案，并标明踩坑点和得分点。建议大家做题时先自己写一遍，再对照答案，而不是直接抄。

3.1 概念与简答题：背熟套路就能拿分

题目一：简述面向对象三大特性，并用生活中的例子分别说明。

参考答案：面向对象三大特性是封装、继承和多态。

封装是指把对象的属性和行为包装在类内部，对外隐藏细节，只通过公开的方法访问。比如洗衣机，你只需要按按钮设定程序，不需要知道内部电机如何运转、水位如何控制。在程序中，封装通过私有属性和公有方法实现，属性不直接暴露，方法内部可加校验逻辑。

继承是指子类可以拥有父类的属性和方法，并可以扩展或重写。比如“交通工具”是一个父类，它有速度、载重等公共属性；“汽车”继承交通工具后，既能继承这些公共属性，又能增加空调、导航等新特性，还能重写“行驶”方法。继承表达了“is-a”关系，并让代码可以复用公共逻辑。

多态是指同一个行为作用于不同对象时，产生不同的执行结果。比如“播放音乐”这个动作，针对“手机”和“电脑”有不同的播放方式，但使用者的操作界面一致。在程序中，多态通过父类引用指向子类对象，调用被子类重写的方法来实现，从而让程序在运行时才确定具体执行哪个版本的方法。

解析与得分点：这题答好的关键不是背定义，而是“例子贴切+概念准确”。每个特性最好都先给一句定义，再补一个生活例子，最后带一句程序中的实现方式。常见失分点：把继承说成“把父类的代码复制给子类”，这是完全错误的理解；把多态和重载混在一起讲，也容易被扣分。记住——多态讲的是运行时的行为，重载是编译期的语法现象。

题目二：重载和重写的区别是什么？请写出各自的基本特征。

参考答案：重载发生在同一个类中，要求方法名相同、参数列表必须不同，与返回值类型无关。重载是编译期的多态，编译器根据参数列表决定调用哪个方法。重写发生在父子类之间，子类对父类中允许继承的方法重新实现，要求方法名、参数列表、返回值类型必须与父类方法一致，且访问权限不能低于父类方法。重写是运行时的多态，由对象实际类型决定调用哪个版本。

解析与得分点：这道题主要考查概念辨析的“精准度”。重点要表述清楚两点：一是重载和重写发生的“位置不同”，二是它们对应的“多态类型不同”。很多人写“重写就是子类的方法把父类的方法覆盖掉”，这样写太口语化，最好用“重新实现”并强调规则约束。如果题目要求举例，就用“一个类里的多个构造方法”作为重载的例子，用“子类方法加@Override注解”作为重写的例子。

3.2 UML类图设计题：画对关系比画得美更重要

题目三：某高校需要开发一个简单的课程管理系统，需求如下：学生拥有学号、姓名和选课列表，可以选课和退课；课程拥有课程编号、课程名称和学分；一个学生可以选多门课程，一门课程可以被多个学生选择；教师可以开设课程，教师拥有工号、姓名。请画出该系统的UML类图。

参考答案分析：这道题重点考查类图元素是否完整、关系是否表达正确。

类设计如下。学生类Student：属性有学号studentId、姓名name、选课列表courses（类型可以用List），方法有selectCourse、dropCourse。课程类Course：属性有课程编号courseId、课程名称courseName、学分credit，方法一般不需要额外设计。教师类Teacher：属性有工号teacherId、姓名name，方法有addCourse（开课）。三者之间的关系是：Student和Course之间存在多对多关联关系，关联方向是双向的；Teacher和Course之间存在一对多关联关系，一个教师可开多门课程，一门课程对应一个教师。

画图时注意三点：第一，类名通常用单数，不要写“Students”；第二，关联关系的线要画在类矩形之间，标清楚多重性——Student和Course的多重性是“1..”对“1..”，Teacher和Course的多重性是“1”对“0..*”；第三，属性类型要写完整，比如String、int、List，方法要写参数类型和返回值类型，很多人漏写类型导致丢分。

解析与得分点：这类题的完整答题流程是“找类 → 定属性 → 定方法 → 找关系 → 标多重性”。最容易漏的是多重性标注，很多同学画了直线但没写“1”和“*”，这是不完整的。另外，有些作业会要求补充一个“选课记录”类，把学生和课程之间的多对多拆成“1对多”加“多对1”，这种设计更规范，如果题目没有明确要求，画多对多关联即可，但如果你能主动拆解成选课记录类，会是一个明显的加分项。

题目四：根据以下场景画出类图。一个动物园里有关养员、动物和食物。饲养员可以给动物喂食，每种动物吃不同的食物，比如老虎吃肉、兔子吃草。动物被饲养员喂养，饲养员管理多种动物。

参考答案分析：这个场景涉及三个类，但关系比上一题复杂，考察的是依赖关系和关联关系的区分。

类设计如下。Animal类：属性有名称name、体重weight，方法有eat(Food food)。Food类：属性有食物名称name。Feeder类（饲养员）：属性有姓名name、编号feederId，方法有feed(Animal animal)。关系上，Feeder和Animal存在关联关系，因为饲养员“管理”动物，是长期存在的关系；Animal和Food之间是依赖关系，因为eat方法的参数是Food，这种关系是临时的、方法级别的。

画图时注意关系线的选择：依赖关系用带普通箭头的虚线，箭头指向被依赖的一方（Animal依赖Food）；关联关系用普通实线，可以在两端标注多重性。Feeder和Animal之间标注“1”对“1..*”。

解析与得分点：这题最大的坑是“把依赖画成关联”。很多同学认为动物吃食物，所以动物和食物之间存在关联关系，但实际上这只是一个方法参数级别的关系，属于依赖。判断标准很简单：如果两个类之间的关系是“方法里用到对方”，属于依赖；如果是“一个类持有另一个类的成员”，属于关联。答题时可以简单写一句“Animal通过eat方法的参数依赖Food，属于较轻的关系”，老师看到这种说明性文字会额外加分。

3.3 代码设计与实现题：动手能力的分水岭

题目五：利用多态设计一个“动物叫声”程序。要求定义一个Animal父类，包含一个叫方法；定义Cat和Dog两个子类，分别重写叫方法。主程序中通过父类引用调用不同子类的叫方法，体现多态。请写出完整Java代码。

参考答案（Java）：

// 父类 class Animal { public void shout() { System.out.println("动物发出叫声"); } } // 子类 class Cat extends Animal { @Override public void shout() { System.out.println("喵喵喵"); } } class Dog extends Animal { @Override public void shout() { System.out.println("汪汪汪"); } } // 测试类 public class Test { public static void main(String[] args) { Animal a1 = new Cat(); Animal a2 = new Dog(); a1.shout(); // 运行时调用Cat的shout a2.shout(); // 运行时调用Dog的shout } }

解析与得分点：这道题的三个关键得分点分别是：父类引用指向子类对象（Animal a1 = new Cat()）、子类方法加了@Override注解、输出结果符合多态预期。很多人会写成Cat c = new Cat()再直接调用，虽然也能输出同样的结果，但没有体现多态，会被扣分。

另外需要注意：如果在主程序里先写了“Animal a1 = new Animal();”，再进行强制类型转换去调用子类方法，那是画蛇添足。多态的精髓就是让父类引用直接调用被子类重写的方法，不需要知道实际对象是谁。

题目六：设计一个图形面积计算系统。要求定义一个抽象类Shape，包含一个抽象方法getArea()；定义子类Rectangle和Circle，分别实现面积计算；主程序用一个Shape数组存储不同图形，遍历调用getArea()输出面积。请写出完整代码。

参考答案（Java）：

// 抽象类 abstract class Shape { public abstract double getArea(); } // 矩形 class Rectangle extends Shape { private double width; private double height; public Rectangle(double width, double height) { this.width = width; this.height = height; } @Override public double getArea() { return width * height; } } // 圆形 class Circle extends Shape { private double radius; public Circle(double radius) { this.radius = radius; } @Override public double getArea() { return Math.PI * radius * radius; } } // 测试类 public class Test { public static void main(String[] args) { Shape[] shapes = { new Rectangle(3, 4), new Circle(5) }; for (Shape s : shapes) { System.out.println(s.getArea()); } } }

解析与得分点：这题最容易犯的错误有三个。第一，抽象类里没有声明抽象方法，或者声明了抽象方法但类没有加abstract修饰符——这是语法错误，直接编译不过。第二，子类没有实现所有抽象方法，如果Rectangle没有重写getArea()，子类也必须声明为abstract，否则编译失败。第三，构造方法里忘了给属性赋值，导致面积计算结果全是0。

还有一个容易忽略的细节：抽象方法不能被private或static修饰，因为抽象方法必须被子类实现，private会阻止子类访问，static和abstract含义冲突。答题时如果写“abstract private double getArea();”会被扣分。

题目七：使用接口实现“支付功能”。定义一个Payable接口，包含pay(double amount)方法；分别用WeChatPay和Alipay实现该接口；编写一个PayService类，在payOrder方法中接收Payable参数并调用pay方法。要求在main方法中演示多态的用法。

参考答案（Java）：

// 接口 interface Payable { void pay(double amount); } // 微信支付实现类 class WeChatPay implements Payable { @Override public void pay(double amount) { System.out.println("微信支付：" + amount + "元"); } } // 支付宝实现类 class Alipay implements Payable { @Override public void pay(double amount) { System.out.println("支付宝支付：" + amount + "元"); } } // 支付服务类 class PayService { public void payOrder(Payable payable, double amount) { payable.pay(amount); } } // 测试类 public class Test { public static void main(String[] args) { PayService service = new PayService(); Payable pay1 = new WeChatPay(); Payable pay2 = new Alipay(); service.payOrder(pay1, 100); service.payOrder(pay2, 200); } }

解析与得分点：这道题的核心考点是“面向接口编程”。PayService的payOrder方法接收Payable接口类型参数，而不依赖具体实现类，这样新增一个支付方式时不需要修改PayService，体现了开闭原则。很多同学会写成“payOrder(WeChatPay p, Alipay a)”，分别写两个方法，这样虽然能运行，但不满足题目需要的多态和接口设计的本意，会被扣分。

答题时建议在代码后补一句说明：“PayService只面向Payable接口编程，后期新增支付方式不影响已有代码。”这句话能明确展示你对接口设计价值的理解，是稳定拿分的关键。

3.4 程序改错题：每一处错误都有讲究

题目八：阅读以下Java代码，找出其中的错误并说明理由，然后写出改正后的版本。

public class Student { private String name; private int age; public Student(String n, int a) { name = n; age = a; } public void setName(String name) { name = name; } public void setAge(int age) { this.age = age; } public void display() { System.out.println("姓名：" + name + "，年龄：" + age); } } public class TestStudent { public static void main(String[] args) { Student s = new Student("张三", 20); s.display(); s.setName("李四"); s.setAge(25); s.display(); } }

参考答案：代码中setName方法存在错误。在setName方法中：

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

这里有一个经典的“参数遮蔽”问题。方法的参数name和类的属性name同名，当执行“name = name”时，两边指的都是参数，而不是类的成员变量，因此类的name属性没有被修改。调用setName("李四")之后，name仍然是“张三”。

改正方法有两种。推荐使用this关键字区分成员变量和参数：

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

也可以在参数前加前缀，避免同名冲突：

public void setName(String studentName) { name = studentName; }

解析与得分点：这题考的是“变量遮蔽”和“this关键字的正确使用”。很多同学一眼看不出问题，因为逻辑上觉得“name = name怎么会有错呢”。在改错题里，只要碰到“参数名和成员变量名相同”的情况，第一反应就要想到this。这题的完整答题结构是：指出错误位置 → 解释错误原因 → 给出改正后的代码。三者缺一不可，只写“这里错了”不解释原因会被扣一半分。

题目九：以下代码试图实现继承关系中的方法重写，请指出错误并改正。

class Animal { protected void eat() { System.out.println("动物吃东西"); } } class Dog extends Animal { void eat(String food) { System.out.println("狗吃" + food); } @Override protected void eat() { System.out.println("狗改成了吃骨头"); } }

参考答案：这道题包含两个层面的问题。

第一个问题是方法设计冗余。Dog类中出现了两个eat方法：一个是@Override注解标记的eat()，它正确重写了父类的方法；另一个是eat(String food)，它属于重载而非重写，并不是错误，但容易引起混淆。如果题目要求体现重写，可以把这个带参数的重载方法去掉。

第二个问题是当存在多个eat方法时，容易让人误以为“eat(String food)”是在重写“eat()”，从而导致理解偏差。改错题的规范答法是：保留与父类签名一致的方法，去掉签名不一致的方法，或者在答题时明确指出哪些方法是重写、哪些是重载。

改正后的简洁版本：

class Dog extends Animal { @Override protected void eat() { System.out.println("狗改成了吃骨头"); } }

解析与得分点：这道题实际考察的是“重写必须方法签名一致”。很多人看到eat(String food)就认为是错误的，这不对——它是合法的重载，只是和重写无关。题目如果明确说“实现重写”，那么只保留一个eat()就可以了。这题的拿分点在于：你能准确区分“重载”和“重写”，并会用“方法签名”这个术语来解释。

题目十：下面的代码在编译时会报错，请找出原因并修复。

abstract class Shape { abstract void draw(); } class Circle extends Shape { void draw() { System.out.println("画圆"); } } class TestShape { public static void main(String[] args) { Shape s = new Shape(); s.draw(); } }

参考答案：问题出在main方法里的“Shape s = new Shape();”。Shape是抽象类，抽象类不能直接实例化。抽象类的存在意义是作为父类被继承，它可能包含没有方法体的抽象方法，直接new一个对象在逻辑上和语法上都不成立。

修复方法：用具体的子类对象来替换，例如：

Shape s = new Circle(); s.draw();

这样不仅修正了语法错误，还体现了面向对象的多态特性——父类引用指向子类对象，调用子类重写后的draw方法。

解析与得分点：这题考的是“抽象类不能实例化”这个基础规则。但要注意，仅仅写出“抽象类不能实例化”还不够，最好把“为什么不能实例化”说一下——因为抽象方法没有方法体，如果允许实例化，调用抽象方法时无从执行，语法上不可能成立。把原因讲清楚，比死记硬背要好得多。

4. 实操环节：从做题到拿高分的完整方法

很多同学觉得“参考答案我看了，会了，但自己做还是不会”。这是很正常的，因为做题和会做题之间，差的不是知识量，而是练习量和答题规范。下面我把实操中影响分数的细节拆开来讲。

4.1 代码题：结构清楚比一次运行成功更重要

作业代码的评分，通常不是只看结果对不对。老师会看代码结构、命名规范、注释质量、是否体现了面向对象思想。我之前帮老师改过作业，见过不少代码能运行但得分不高的例子，原因很集中：

第一，一个类里塞了所有逻辑。把main方法、类定义、方法实现全挤在一个文件里，没有分开类，这让封装性和可读性都很差。作业题如果真的要求“体现面向对象思想”，就一定要每个类一个文件或至少每个类独立成块，不要把所有类和测试代码揉在一起。

第二，命名不规范。类名用拼音、属性名用单字母（比如a、b、c），都是扣分点。规范的命名应该是：类名大驼峰（StudentInfo），变量名小驼峰（studentName），常量全大写（MAX_SIZE）。哪怕老师没明确要求，规范命名也会让印象分上升。

第三，没有写注释。作业和考试不一样，考卷上写了就得分，作业代码如果完全没有任何注释，哪怕功能正确也显得不够用心。我的建议是：类定义前写一行类说明，每个方法前写一句功能说明，关键逻辑处加一行注释，不用多，但要有。

第四，缺少必要的输出提示。比如“请输入矩形宽度：”这类提示，在交互式程序里是基本要求。很多人直接把输入框空着，用户根本不知道要输入什么。

4.2 画图题：规范细节决定得分档位

UML类图作业，最容易丢分的地方不是“类没找对”，而是“关系符画错”和“多重性漏标”。我整理了一个速查表，建议画图之前先对照一遍。

六种关系的画法速查：

• 继承（泛化）：空心三角箭头实线，从子类指向父类
• 实现：空心三角箭头虚线，从实现类指向接口
• 关联：普通实线，可标注多重性
• 聚合：空心菱形实线，菱形在整体侧
• 组合：实心菱形实线，菱形在整体侧
• 依赖：普通箭头虚线，从使用方指向被使用方

画类图时，属性和方法前的符号也不能搞错。public用+，private用-，protected用#。这些基础符号如果错了，会直接影响老师对“是否掌握UML”的判断。多重性要写在线的两端，比如学生选课场景的“1..”和“1..”。有些同学只画线不标数字，这在严格评分时会被扣分。

4.3 作业加分项：这些细节让你的答案跳出“标准答案”

有几个细节，在参考答案里未必会写，但如果你能补上，通常会给老师留下好印象：

• 在代码里加@Override注解。这是Java提供的编译期校验，能帮助发现重写错误，也是行业惯例。
• 在接口实现类上写“implements”后，在类注释里简要说明“该类实现了XX接口的XX方法，业务逻辑是……”用一句话讲清设计意图。
• 在UML类图旁边附一段简短的关系说明文字，比如“Student和Course为多对多关联，通过选课记录表维系统维护”。这直接体现你的建模思考过程。
• 在代码题末尾主动写测试用例。不需要很多，两三个边界用例就能证明你的程序经得起推敲。

5. 常见问题速查与提交前自查清单

最后一个部分，我把批改作业和答疑时最常见的十几类问题整理成一个速查表，按症状、原因、解决方式列出。

这份表格可以当考试前一天的自查清单用。每看一行，就问自己“我是否真的能解释清楚这一条”，如果能，说明对应知识点基本过关；如果不能，回到前面的对应小节重新看一遍。

5.1 提交前的十分钟自检

每次交作业前，花十分钟做一遍下面这个检查流程，能避免大多数低级错误。

第一，编译运行检查。把代码复制到一个干净的目录，重新编译运行一次。很多同学在IDE里能运行，是因为IDE自动补全了依赖，但提交到作业系统后编译失败。如果作业要求提交源代码，最好在命令行或干净的工程里验证一遍“从零编译”是否通过。

第二，命名与格式检查。检查类名是否大写开头，方法名是否小写开头，是否所有缩进都一致。有些作业系统会对文件编码敏感，尽量不要用包含中文字符的类名和文件名。

第三，UML图的组件检查。画完图后逐个元素检查：每个类是否有类名、属性、方法；属性是否有类型；方法是否有返回值；关系线是否标了多重性；是否漏掉了泛化或实现关系。

第四，代码注释检查。看每个类和每个方法是否有注释，关键业务逻辑有没有一行说明。注释不是越多越好，但完全没有一定是减分项。

第五，试题答案的完整性检查。简答题是否回答了所有小问，画图题是否按要求标注了所有内容，改错题是否既指出了错误又写了改正代码。改错题经常有人只改不解释，只看到“错误原因”那半行没写，就会被扣分。

6. 面向对象学习的延伸建议

最后结合我个人的辅导经验说几句。面向对象不是背出来的，是练出来的。作业题里的每个例子，都建议亲手写一遍，不能只看参考答案。我见过很多同学，把习题答案背得滚瓜烂熟，但一到期末考试换了新场景就完全不会设计。原因很简单：答案只告诉你“是什么”，没让你练“怎么做”。

练的时候，可以自己给自己出题。比如学完多态，就写一个“员工工资结算系统”，不同岗位的员工有不同的工资计算方式；学完接口，就写一个“文件导入导出系统”，支持Excel和CSV格式。这些自拟题目不需要太长，能练到“拿到需求能拆出类、能定义接口、能写出可运行代码”就算过关。

再一个小技巧：做完作业后，试着把答案里的代码用自己的话讲给别人听，或者写在笔记里。如果能清晰地说出“这里的Animal为什么要定义为抽象类”“这里的payOrder为什么接收接口而不是具体类”，说明你是真的理解了。如果讲不出来，那这道题的逻辑还没有真正变成你的。

面向对象部分的作业，本质上是在帮你建立一种“抽象思维”。这种思维不会因为你写对一道题就突然获得，而是在一次次改错、一次次重构代码中慢慢养成的。作业里那些看起来重复的练习题，其实每道都在强化你头脑中的“建模能力”。希望这篇整理能帮你把作业做得更顺，也更清楚地看到每道题背后的考察逻辑。