Java面向对象核心：继承多态抽象类接口10道编程题解析

1. 项目概述与练习价值分析

1.1 这组编程题到底在考什么

"sdut-Java面向对象-06 继承和多态、抽象类和接口（编程：1-10题）"，看到这个标题，经历过Java课程的人都懂——这是面向对象体系里最核心、也最容易让人卡壳的一关。前面几单元学类、对象、封装，基本都是单打独斗；到了这个单元，类与类之间开始产生关系了，继承让子类拥有父类的能力，多态让同一个方法在不同对象上有不同表现，抽象类和接口则逼着你用"抽象"的思维去设计程序骨架。

很多同学在这10道题上栽跟头，不是因为题目本身有多难，而是对几个核心概念的理解停留在"背定义"层面，一到写代码就不知道什么时候用抽象类、什么时候用接口、为什么父类引用指向子类对象能调用子类重写的方法。这些题目设计的用意，就是把你从"能写出来"推向"真正理解为什么这么写"。

这10道编程题的价值不仅仅在于让实验报告有内容可填，而在于它覆盖了在校招笔试和面试里出现频率极高的知识点。我面试过不少候选人，一问"抽象类和接口的区别"，能答全的人不多；一让手写一个多态场景，更是漏洞百出。如果你能把这份练习里的每一道题都搞透，后面找工作刷八股文的时候会轻松一大截。

1.2 十个题的难度递进与知识地图

根据教学规律和同类练习的编排逻辑，这10道题一般会按照"继承基础→重写与重载→多态应用→抽象类→接口→综合设计"的路径递进。前几题通常是定义父类子类关系，中间穿插构造器调用、方法重写这类细节，后面则开始用抽象类和接口组织更复杂的结构。

从知识地图来看，这10道题围着三条主线展开：

第一条主线是继承关系。包括extends关键字的用法、super关键字对父类成员的访问、子类构造器对父类构造器的调用、protected访问修饰符的作用范围。

第二条主线是多态。核心是父类引用指向子类对象、方法重写的动态绑定机制、向上转型和向下转型的时机与风险、instanceof的合理使用。

第三条主线是抽象类和接口。包括抽象方法的定义与实现、模板方法设计模式的雏形、接口的定义与实现、接口的多继承特性、以及抽象类和接口在什么场景下选谁。

把这三条主线串起来，你再看这10道题，就不是一道一道孤立的小题了，而是一个环环相扣的知识体系。下面的内容我会按这个体系逐个拆解，每一部分都会结合题目里常见的考察点展开，最后总结一些我实际调试这些代码时踩过的坑。

2. 继承与多态的四个关键认知

2.1 继承的本质是抽取共性，而非代码复制

很多初学者写继承时，脑子里想的是"父类有的东西子类不用重新写了，省事"。这个理解方向没错，但没有get到继承的真正意义。继承的首要目的是抽取共性，把多个类共同的状态和行为上提到父类，从而建立起类型之间的层次关系。

举个例子，假设题目里定义了动物类Animal作为父类，子类有Dog和Cat。Animal有name属性和eat()方法，Dog和Cat都继承这些成员。这时候你设计的不是"Dog把Animal的代码复制了一份"，而是"Dog是一种Animal"，这种"is-a"关系才是继承的灵魂。而判断是否该用继承，标准也恰恰是子类是否确实是父类的一种。

从编译角度说，继承带来的直接好处是子类自动获得了父类的非私有成员。但如果只想复用代码，不构成is-a关系，那继承就不是好选择——实际开发中我更倾向于用组合（在一个类里持有另一个类的引用）来代替这种情况，后面在题目分析中会再展开。

2.2 方法重写与方法重载的区别

重写（Override）和重载（Overload）是Java语法里两个长得像但语义完全不同的概念，也是这类练习里必考的点。

重写发生在父子类之间，要求方法名、参数列表、返回值类型完全相同（从Java 5开始支持协变返回类型，即子类可以返回父类返回类型的子类型），访问修饰符不能比父类更严格。重写的意义在于子类对父类的方法行为进行替换，实现多态。比如父类Animal的eat()输出"Animal eating"，子类Dog重写后输出"Dog eating"，父类引用指向Dog对象时调用eat()，跑的是Dog的版本。

重载则发生在同一个类内部，方法名相同、参数列表不同（个数、类型或顺序），与返回值无关。重载是编译器在编译阶段就能确定调用哪个版本的，属于静态绑定；重写则需要运行时根据对象实际类型决定，属于动态绑定。

练习里经常出现的坑有两个：一是子类方法写成了重载但以为在重写，比如父类有eat(String food)，子类写了个eat()，这俩参数都不一样，根本不是重写；二是重写时忘了加@Override注解，导致方法签名写错编译器也不报错，程序跑起来才发现没实现多态。我的习惯是从一开始就给所有重写的方法加上@Override注解，让编译器帮我检查签名是否匹配。

2.3 构造器在继承链中的执行顺序

构造器执行顺序是这类练习的经典考点，也是很多程序出bug的隐藏原因。Java规定：子类的构造器第一行必须直接或间接调用父类的构造器，如果子类构造器没有显式写super()，编译器会默认加一个无参super()。

这就带来一个执行顺序问题：创建子类对象时，先执行父类构造器，再执行子类构造器。从内存分配的角度看，子类对象在堆内存里其实包含了一块父类的区域，父类构造器先把这块区域初始化好，子类构造器再在此基础上初始化自己特有的字段。

我在刚学这个知识点时犯过一个典型错误：父类只有一个带参构造器，没有无参构造器，子类构造器里也没有显式调用super(参数)，结果编译直接报错"Implicit super constructor Animal() is undefined"。正确做法有两种：要么在父类里补一个无参构造器，要么在子类构造器第一行显式写super(name)。

另外还要留意一个执行顺序细节：字段初始化和构造器执的先后。看如下代码：

class Animal { String name = "animal"; Animal() { printName(); } void printName() { System.out.println(name); } }

创建Animal对象时，字段初始化在构造器方法体的代码之前执行，所以name已经是"animal"。但如果创建的是子类Dog对象，Dog继承了name字段并且Dog重写了printName()，那么父类构造器里调用的printName()会优先找到Dog重写的版本。如果Dog里的printName()输出自己定义的字段，而这个字段还没初始化，就会输出null。这种由动态绑定带来的构造器内调用虚方法的隐患，不仅是考试常客，也是实际开发中一道经典"坑题"。

2.4 动态绑定与转型

多态的核心机制是动态绑定，也叫后期绑定或运行时绑定。Java虚拟机在调用实例方法时，编译阶段编译器只知道变量的静态类型（声明类型），到运行阶段才根据对象的实际类型确定该调用哪个方法。这就是为什么Animal animal = new Dog(); animal.eat();会输出Dog重写后的eat()。

向上的转型（向上转型）是安全且自动的，因为Dog必然是Animal，编译器允许你声明一个Animal类型的变量去指向Dog对象。但向上转型的代价是，通过这个父类引用只能调用父类中定义的成员，子类新增的独有方法调用不了——你没办法用一个Animal变量去调用dog专属的fetch()方法。

如果确实需要调用子类的特有方法，就需要向下转型。向下转型不是自动的，必须显式写强制类型转换，并且有风险：如果对象实际类型不是你要转的类型，运行时会抛出ClassCastException。题目里如果要求实现这种场景，通常配合instanceof来做类型检查。

if (animal instanceof Dog) { Dog dog = (Dog) animal; dog.fetch(); }

instanceof的语义是"对象是否是这个类的实例，或这个类的子类的实例"。但这里有个坑：当animal变量本身是null时，instanceof的结果是false，不会抛出空指针异常，这一点在判空时经常被利用。

3. 抽象类与接口的深度辨析

3.1 抽象类到底抽象在哪里

抽象类是Java中用abstract修饰的类，它允许包含抽象方法——只有方法签名、没有方法体，具体实现在子类中完成。当一个类含有抽象方法时，这个类必须声明为抽象类。抽象类不能实例化，但可以有构造器，可以包含普通成员变量、具体方法、静态方法等。

抽象类的价值在于"定义规范"，强制子类必须实现某些行为，同时把公共的实现细节沉淀在父类里。在设计层面，抽象类是"模板"的概念——它规定了你必须具备什么能力，至于能力怎么实现，由各个子类自由发挥。

模板方法设计模式就是抽象类的典型应用场景。父类定义一个模板方法，里面规定了算法的骨架，把某些步骤声明为抽象方法留给子类实现。比如题目里可能要你设计一个"游戏角色"抽象类，里面定义roleName属性和attack()抽象方法，具体是物理攻击还是法术攻击由不同角色子类实现，而父类还提供一个默认的commonAttack()具体方法供子类继承复用。这就是抽象类"部分实现、部分抽象"的特质，也是它与接口最大的区别。

3.2 接口的演进与多继承方案

接口在Java中经历了比较大的演进。JDK 8之前，接口中只能定义抽象方法和常量（public static final修饰）；JDK 8引入了default方法和static方法，让接口可以包含有方法体的默认实现和静态工具方法；JDK 9之后又加入了private方法，用于在接口内部提取公共代码。

从语义上讲，接口和抽象类承载的抽象层次不同。接口更多的是一种"契约"或"能力"的声明，它不关心实现细节，只要求实现类具备某种能力。因为Java类只能单继承，但可以implements多个接口，所以接口是Java实现多继承效果的主要途径。

题目里如果有"运动员"和"大学生"两个接口，"研究生"类同时implements这两个接口，就很好地体现了接口的多实现能力。这时要注意接口中可能出现同名默认方法，如果两个接口都有默认方法kickoff()，实现类必须重写这个方法，否则编译器会报告冲突错误。

interface Runner { default void run() { System.out.println("Runner default run"); } } interface Swimmer { default void run() { System.out.println("Swimmer default run"); } }

像上面这种两个接口都有同名默认方法run()，任何想要同时实现Runner和Swimmer的类都必须提供自己的run()实现，编译器才能消除歧义。这道题如果出现在你的练习里，你应该知道它考察的就是接口默认方法冲突的解析规则。

3.3 抽象类 vs 接口：选择标准与方法论

在实际做练习和真实项目开发中，"用抽象类还是用接口"是最常被问到的设计决策。我的判断标准可以总结为五句话。

第一，语义关系是is-a还是can-do。如果多个类在本质上属于同一类事物，具备明显的"是一种"关系，用抽象类；如果只是具备某种能力，用接口。

第二，是否需要共用代码。抽象类里可以放通用字段、具体方法体，子类直接复用；接口（除default方法和static方法外）不能提供实现代码。如果多个类有大量公共代码，抽象类更合适。

第三，是否需要多继承。Java类单继承，如果你想让你设计的类同时拥有多个角色的属性能力，只能通过接口实现。

第四，对状态的需求。抽象类可以有实例变量，可以保存状态；接口里的字段默认是静态常量，无法保存对象状态。如果你的抽象体系里需要维护对象的状态值，选抽象类。

第五，版本演进情况。对外发布的API如果后续要增加方法，接口可以通过default方法实现向后兼容，而抽象类新增抽象方法会让所有子类都跟着改。

下面用表格把两者的核心区别整理清楚：

4. 1-10题典型题型拆解与实践路径

4.1 前3题：继承基础与成员访问控制

这类题目通常会给定一个需求描述，比如"定义Person类，有姓名、年龄属性，定义Student类继承Person类，增加学号属性，输出完整信息"。看起来简单，但考察的细节很多：属性用private还是protected、子类能否直接访问、构造器怎么写。

我的建议是：父类属性统一用private，对外提供protected的getter/setter或public的getter/setter，子类通过方法访问，而不是把属性改成protected去直接访问。原因有几个。private保证了封装性，subclass对父类内部字段的依赖越强，后续父类改字段类型时影响面就越大。protected字段虽然子类可以访问，但一旦类层级深了，字段被多处直接修改，调试成本会急剧上升。

构造器方面，父类如果有带参构造器，子类构造器一定要显式调用super(参数)。如果你偷懒不写，编译器要求父类必须存在无参构造器，否则直接编译失败。这个错误在初学者中出现的频率极高。

第3题往往开始引入方法重写。题目会要求子类重写toString()或一个自定义的displayInfo()方法。这里需要注意：println()打印对象时默认调用toString()，如果没重写toString()，打印出来的是"类名@地址"这种难看的格式，这在实验输出里会显得很业余。

4.2 4-6题：多态场景与类型转换

从第4题开始，题目大概率会要求你写一个多态场景。典型的需求是：定义父类Shape，有计算面积的方法；定义子类Circle、Rectangle、Triangle，分别重写面积计算方法；在测试类里用Shape数组装多个子类对象，循环调用area()。

这类题考察的就是动态绑定：编译器看到的是Shape类型的方法调用，运行时会执行每个对象的真实类型对应的面积计算方法。这就意味着你写代码时应该站在"父类统一接口"的角度思考，而不是在循环里用if判断每个对象具体是什么类型再去单独调用。后者恰恰是新手容易犯的面向过程式思维。

第5、6题可能会出现向上转型和向下转型的交替使用，配合instanceof进行安全判断。例如：

Shape s = new Circle(2.0); double area = s.area(); // 动态绑定，调用Circle的area() if (s instanceof Circle) { Circle c = (Circle) s; System.out.println("半径：" + c.getRadius()); }

这里要注意的是，虽然s的静态类型是Shape，但instanceof判断的是s所指向对象的实际类型。还有一点很多人容易忽略：子类对象在向上转型后，如果父类引用调用的方法在子类中没重写，那调用的就是父类自己的实现，无法触发多态效果。

4.3 7-8题：抽象类与模板方法设计

第7、8题应该会用抽象类来组织一组类。典型题目比如定义抽象类Employee，包含员工编号、姓名属性和一个计算工资的抽象方法calculateSalary()，然后让Manager类和Developer类继承它，各自实现工资计算逻辑。

写法上分两步。第一步，在抽象类中定义抽象方法和公共方法。这里可以考虑用模板方法模式：父类提供一个final的showSalaryInfo()方法，内部先输出基础信息，再调用calculateSalary()输出具体工资；calculateSalary()是抽象方法，由子类实现。第二步，在子类中实现抽象方法，并补充子类独有的字段，比如Manager有bonus属性，Developer有projectCount和perProjectPrice属性。

这种设计模式下，新增一种员工类型就只需要写一个子类，实现工资计算方法，不需要改任何已有代码，体现了面向对象设计里"开闭原则"的思路——对扩展开放，对修改关闭。练习里如果出现了这种要求，你应该感觉到题目背后的意图不只是考语法，而是在引导你用设计的视角去看代码结构。

4.4 9-10题：接口多实现与综合设计

最后的综合题通常会把接口、抽象类、继承和多态全部串起来。比如让我设计一个"交通工具系统"：定义Moveable接口，里面有个move()方法；定义抽象类Vehicle实现Moveable，提供车牌号属性和一个showInfo()方法；再让Car、Bike分别继承Vehicle并实现move()。

还有一个常见的接口多实现设计是"仿生机器人"场景：定义Run接口和Swim接口，Robot类同时实现两个接口。或者"学生活动"场景：定义Study接口和Sport接口，GoodStudent类实现两个接口并重写所有抽象方法。

写综合题时，我建议按以下顺序操作：先画一张简单的类关系图（接口在上，抽象类在中间，具体类在下面），标注继承和实现关系；再按依赖次序定义接口、抽象类、具体类；最后写主测试类。题目如果要求用接口类型引用去调用方法，比如Run r = new Robot();，这里要注意接口类型的引用只能调用接口中声明的方法，不能调用实现类里独有的方法。代码结构上尽量把接口、类分开定义，一个文件里不要塞多个public类，这在拼题平台提交时经常引发编译问题。

5. 高频编译错误与运行时问题排查实录

5.1 编译错误速查表

结合历年学生在拼题平台做这类题目的报错情况，下面这些编译错误你几乎一定会遇到至少一两个：

这里重点说下"cannot reduce the visibility"这条。很多同学不理解，为什么父类的方法是public，子类重写时改成private就会报错。道理在于：如果父类类型的引用在某个外部代码里调用这个方法，外部代码不关心对象实际是哪个子类，它只知道通过父类接口可以调用这个方法。如果子类把它改成private，动态绑定时外部代码就无法访问了，破坏了多态的一致性。反过来，子类把protected改成public是被允许的，因为更开放不会破坏接口约定。

5.2 运行时逻辑层的坑

编译过了不意味程序是对的，运行时出问题更让人头疼。我总结了几类高发问题。

第一个是空指针异常。这种题里最常见的原因是被实例化的对象没有正确初始化。比如写了Shape[] arr = new Shape[3]; 然后忘了给arr[1]赋子类对象，循环访问时就空指针。也有时候是子类构造器里没有把父类的字段都填上，导致后面getter返回null。

第二个是类型转换异常ClassCastException。没有用instanceof判断就直接向下转型，对象实际类型跟目标类型不匹配。这种异常往往在循环里隐藏很深，建议在关键转换处加instanceof保护并打印日志。

第三个是输出格式不符合题目要求。拼题平台这类判题系统通常是按输出字符串精确比对，多一个空格、少一个换行都可能导致答案错误。我踩过这个坑，前几道题代码逻辑全对，但输出末尾多了个空格被判错。做题前建议先把题目给的输入输出样例读透，特别是输出里含中文冒号、空格、逗号的地方，严格照抄样例格式。

第四个是多态没生效。程序正常运行，但输出结果显示调用的还是父类的方法。这通常是因为子类没有重写该方法，或者重写的时候方法签名跟父类不一致，导致变成了重载。解决办法很简单：检查子类方法上有没有@Override注解，没有的话编译器不会帮你检查签名。加上注解后如果编译报错，就能立刻发现签名不匹配的问题。

5.3 一个有代表性的调试案例

我在调试一个工厂类题目时遇到过一种很有意思的情况。题目要求设计一个抽象类Instrument，里面定义抽象方法play()，然后有Piano和Violin两个子类。测试代码写的是：

Instrument[] instruments = {new Piano(), new Violin()}; for (Instrument i : instruments) { i.play(); }

看起来完全正常，运行后Piano和Violin的play()都执行了，但部分题目的输出要求里有一个总控类MusicCompany或者要求用接口类型的变量去指向对象。问题出在某个子类里我重写play()时不小心写成了play(String name)，加了个参数，于是它不再是重写，而是重载。编译器没报错，因为两个方法签名不同，父类也没有同名同参数的方法，但多态就这样悄悄失效了。测试结果就是：其他部分输出正常，唯独这个子类继承了父类的空实现或默认实现，输出缺失。

这种bug特别难排查，因为你盯着一行一行的代码看了很久，逻辑完全没毛病，但程序就是表现得不对。最终定位时靠的就是@Override注解的辅助，以及把父类和子类所有方法的全限定签名拉出来对比。我的经验是：但凡涉及重写的地方，一律加@Override，并且写完子类后建议反查一遍父类的方法签名，杜绝这种"以为重写了、其实没有"的情况。

6. 做题方法与后续提升建议

刷这10道题时，不建议一道一道按顺序闷头写。先把题目通读一遍，把每道题考察的知识标在题号旁边，你会发现很多题都在反复验证同一个点。比如你标出来会发现，构造器调用顺序和重写检查至少出现了三四次，这说明出题人希望你在不同场景下反复强化这个认知。

做题优先级上，我建议先保证前6题正确率100%，再攻后面的抽象类和接口综合题。前6题是语法基础，如果这里还频繁编译失败或逻辑错误，说明你对继承和多态的基本语法还没形成肌肉记忆。后4题则更多考验设计能力，需要你从"写代码"切换到"设计代码"的思维方式。

另一个容易被忽视的点是：代码的可读性和命名规范。拼题平台只比对程序输出，不会管你的类名起得是否规范，但你自己要养成好习惯。父类命名用抽象的概念（Animal, Shape, Employee），子类命名用具体的概念（Dog, Circle, Manager），接口命名用"能力形容词"（Moveable, Runnable）等。这些命名习惯在你做综合题时会直接影响你编码的流畅度。

学完这个单元后，我还有两个进阶方向建议。一是去读一读官方Java Tutorial里关于Polymorphism和Abstract Methods and Classes的章节，英文原版讲得很清楚，搭配练习食用效果极佳。二是自己造一个小项目，比如设计一个"动物园门票系统"，里面必须有动物父类、不同动物子类、喂食多态方法、以及售票统计的接口，在自己造轮子的过程中才能真正把这些概念内化。

最后再分享一个小技巧：遇到模棱两可的继承设计时，写一个极简的Demo验证你的想法。Java里验证一个语法点往往十行代码以内就能搞定，比如验证构造器顺序、验证默认方法冲突规则、验证instanceof的边界行为。我到现在遇到不确定的Java语法都还会开一个临时类去跑一下，这种动手验证的习惯，比翻十篇博客都管用。