面向对象综合练习：从类设计到多语言实现

1. 项目概述：day16这道坎到底在练什么

说实话，很多自学编程的人都会在某个学习阶段遇到一个转折点——语法书翻了好几遍，视频也看了不少，小练习都会做，但一碰到稍微综合一点的需求就卡壳。如果你正处在这样的阶段，那么day16-面向对象综合练习（上）这一课就是为你准备的。

这一天的内容，本质上是把之前零零散散学过的类与对象、构造方法、封装、继承、多态、抽象类与接口等面向对象核心概念，放进一个相对完整的场景里去做串联和落地。它不是单纯地让你再敲一遍某个知识点的示例代码，而是要你像一个真正的开发者那样，从需求分析、类结构设计、代码实现到测试验证，完整地走一遍面向对象的开发流程。

先说清楚一个容易让人迷惑的地方：为什么叫“综合练习（上）”？这意味着练习内容和配套的知识点在一个系列里被拆成了两段，前半段重点搞定类设计、封装、继承这三个基础基石，后半段才上多态、抽象类和接口这些偏“进阶”的特性。也就是说，如果你练完今天的内容，至少应该能独立设计出一个多类协作的小型程序结构，并清楚每个类该放什么字段、什么方法，以及类与类之间的继承关系怎么组织。

这篇文章适合谁？适合那种已经学完Java/C++/Python基础语法、正在面向对象门口徘徊的初学者，也适合那些上过一遍课但缺乏综合训练、想通过实际案例巩固OOP思想的同学。我会用真实的练习案例、三语言对比的写法思路，以及我自己当年踩过的坑，把这节课的内容拆透了讲。

2. 练习背后的设计思路：为什么面向对象必须靠“做题”才能学会

2.1 从“能看懂”到“会设计”的鸿沟

先问一个问题：你读代码的能力和写代码的能力是一回事吗？绝大多数初学者都会发现，读别人写的面向对象代码，好像每个关键字、每个语法都认识，合上书让自己从零开始设计一个系统，大脑就一片空白。这不是你笨，而是“理解”和“设计”之间本来就有巨大的鸿沟。

举个例子，你在书上看到public class Cat extends Animal，你觉得懂了——Cat是Animal的子类。但是当需求变成“有猫有狗有鸟，它们都会叫，但叫声不同，有的还会飞、会游泳”时，你的第一反应是什么呢？很多人的第一反应是：给每个动物都写一个类，然后每个类里都写一个makeSound()方法。运行起来没问题，但代码大量重复，想要新增一种动物就要复制粘贴一整套方法，改一个逻辑就要到处改。

面向对象的综合练习，本质上就是强迫你面对这类问题。它不会直接告诉你“请用继承和多态来实现”，而是抛出一个带着业务气息的需求，让你自己去判断：哪些东西是公共的，应该抽成父类？哪些行为是变化的，应该被子类重写？哪些能力是某些对象独有的，应该用接口来约束？这种设计判断力，就是靠一道道综合练习练出来的。

2.2 综合练习的经典套路：从需求中提炼类

我做这类型项目有一个经验：碰到综合练习，永远不要上来就写代码。哪怕脑子里已经有了大概的方案，也要先走一遍“需求分析 → 找名词 → 定类 → 画关系”的流程。学校里的练习题目通常不会太复杂，但核心逻辑和大厂面试的手写题、实际工作中的模块设计，基本是一个套路。

以常见的学生管理系统、图书管理系统、游戏角色系统为例，我们可以把一套标准方法的步骤拆成四步：

1. 找名词。把题目里出现的所有“人”“物”“概念”圈出来。比如“学生”“老师”“课程”“成绩”“班级”，这些名词大概率就是你要设计的类。
2. 找动词。名词旁边跟着的动作，就是方法。例如“学生选课”“老师录入成绩”“课程显示信息”，这些动作决定了类中要定义什么行为。
3. 找形容词/归属关系。比如“研究生是一种学生”“讲师是一种老师”“课程有学分、有编号”，这些关系和属性决定了类与类之间的继承关系、字段类型。
4. 区分“是什么”和“有什么”。A是B的一种，用继承；A拥有B，用组合。也就是is-a关系用继承，has-a关系用字段引用，这个判断往往就是面向对象设计里最难的一步。

为什么很多人练习做不对？大多数情况不是语法问题，而是一上来就写public class Student，写着写着发现“研究生”和“本科生”很多代码重复，才回来补继承，最后整个类的关系变得一团糟。面向对象是设计先行的事情，动手之前花十分钟画图整理，省下来的可能是几小时的重构时间。

2.3 练习案例的选择逻辑：大学管理系统可能是最合适的第一道题

day16的练习题很多教材会选“学生/教师/课程”这类主题，原因只有两个字：熟悉。你天天在校园里生活，不需要额外的行业背景知识就能理解需求，能把全部注意力放在OOP的设计和实现上。这也顺便说明了一个道理：练习难度应该体现在设计思考上，而不是业务背景上。

我后面展开的案例也遵循这个原则。做一个带继承关系的校园角色信息管理系统，包含普通学生、研究生、教师三种角色，每个角色都有基本信息展示和各自的独有操作，同时提供一个统一的测试入口。这个系统麻雀虽小，但足够覆盖day16上半段练习的核心知识点：类与对象、构造方法重载、封装（private字段 + getter/setter）、静态成员、继承（父类子类、super调用）、方法重写。更重要的是，你能在一道题里同时看到这些知识是怎么协同工作的，而不是像之前学语法那样，一个知识点配一道独立的小题。

3. 核心案例实操：构建校园角色管理系统的完整过程

3.1 需求明细与类结构设计

这里我们先把具体需求定下来。假设题目要求实现一个校园角色信息管理系统，需要支持三种角色：普通学生、研究生、教师。所有角色都有姓名、年龄和自我介绍的功能；学生需要显示学号和所在班级；研究生的显示除了学号、班级之外，还需要导师姓名和研究方向；教师需要显示工号和所授课程。

这样一个需求你拿到的第一眼可能觉得毫无头绪。没关系，按照老规矩走一遍。找出所有名词：学生、研究生、教师、姓名、年龄、学号、班级、导师、研究方向、工号、课程。再找动词：自我介绍、显示信息。最后梳理一下关系：研究生是一种特殊的学生，所以研究生继承学生类；学生和教师都是校园成员，抽一个公共父类Person最合理。关系图和类职责就这样确定下来了。

这里我给出一个类结构设计的经典模板，字段名和方法名用英文，方便你对照代码：

注意一个细节：GraduateStudent首先是一个Student，它继承了学号和班级，同时加了导师和研究方向两个额外字段。这里一定要把握住“继承表达的是一种层次递进”这个直觉——它不是一个空泛的语法概念，而是在建模真实世界里的“是一种”关系。

3.2 用Java实现：最经典的面向对象语法演示

如果你的主语言是Java，以下代码就是一个标准的day16上半段练习答案。我们先定义一个Person父类：

java复制public class Person {
    protected String name;
    protected int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void introduce() {
        System.out.println("我叫" + name + "，今年" + age + "岁。");
    }
}

这里有几个值得留意的点。第一，字段修饰符用的是protected而不是private。在综合练习里，新人很容易纠结到底用哪个——如果父类字段设为private，子类就无法直接访问，必须通过getter；如果设为public，封装性又破坏了。而protected的意义就在于：允许子类直接访问，同时对外部完全隐藏，这是继承场景中最贴合语义的封装层级。第二，构造方法接收name和age并完成赋值，把对象初始化的逻辑收口在构造器里，而不是创建对象后一个个去set。这个习惯非常关键。

接下来是Student子类：

java复制public class Student extends Person {
    private String studentId;
    private String className;

    public Student(String name, int age, String studentId, String className) {
        super(name, age);
        this.studentId = studentId;
        this.className = className;
    }

    @Override
    public void introduce() {
        super.introduce();
        System.out.println("我是一名学生，学号是" + studentId + "，班级是" + className + "。");
    }

    public void study() {
        System.out.println(name + "正在学习。");
    }
}

super(name, age)这行是综合练习里最容易出错的点之一。很多初学者只知道“要调用父类构造方法”，却不理解为什么必须这么做。原因是：Java规定，创建子类对象时，必须先完成父类部分的初始化，而父类字段name、age是在父类构造器里赋值的。如果你不显式调用super，编译器会尝试调用父类的无参构造器，而我们的Person类只有一个带参构造器，没有无参构造器，直接报编译错误。这就是父类显式定义带参构造器之后，子类必须显式调用super的根本原因。

GraduateStudent继承Student，代码逻辑完全一样，但字段更进一步：

java复制public class GraduateStudent extends Student {
    private String supervisor;
    private String researchField;

    public GraduateStudent(String name, int age, String studentId, String className,
                           String supervisor, String researchField) {
        super(name, age, studentId, className);
        this.supervisor = supervisor;
        this.researchField = researchField;
    }

    @Override
    public void introduce() {
        super.introduce();
        System.out.println("我是一名研究生，导师是" + supervisor + "，研究方向是" + researchField + "。");
    }

    public void research() {
        System.out.println(name + "正在研究" + researchField + "方向。");
    }
}

注意这里super.introduce()连续两级调用：GraduateStudent调Student的，Student调Person的。最终打印出来是一段层层递进的自我介绍——这种“子类方法在父类方法基础上扩展”的写法，是重写方法中最合理、最常用的模式。你会看到很多老手写@Override方法时，总是先把父类能力“继承”下来，再叠加自己的增量逻辑，而不是完全推翻重写，这是写继承代码的一个重要习惯。

3.3 用Python重写一遍：动态语言的面向对象有什么不同

如果你主攻Python，一样能完成同样的练习，而且在代码长度上会明显更短：

python复制class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"我叫{self.name}，今年{self.age}岁。")


class Student(Person):
    def __init__(self, name, age, student_id, class_name):
        super().__init__(name, age)
        self.student_id = student_id
        self.class_name = class_name

    def introduce(self):
        super().introduce()
        print(f"我是一名学生，学号是{self.student_id}，班级是{class_name}。")

    def study(self):
        print(f"{self.name}正在学习。")


class GraduateStudent(Student):
    def __init__(self, name, age, student_id, class_name, supervisor, research_field):
        super().__init__(name, age, student_id, class_name)
        self.supervisor = supervisor
        self.research_field = research_field

    def introduce(self):
        super().introduce()
        print(f"我是一名研究生，导师是{self.supervisor}，研究方向是{self.research_field}。")

    def research(self):
        print(f"{self.name}正在研究{self.research_field}方向。")

Python和Java相比，有几个语法层面不同的地方值得对照。Java用extends关键字显式声明继承，Python在类名后面的括号里写父类；Java有@Override注解来标记重写，Python完全不加标记；Java的字段需要显式声明类型，Python直接在__init__里赋值即可。

但最核心的设计思想——父类抽公共成员、子类用super().__init__完成父类初始化、子类方法先调父类再补充自己的逻辑——是完全一模一样的。这也印证了一个道理：面向对象不是某种语言的语法，而是一套跨语言的思维方式。先掌握设计，再去适应具体语言的写法，效率会高很多。

3.4 C++视角：掌握这些，你才算真正理解了OOP的底层

如果你用的是C++，这个练习还会多一层内容，因为C++里除了继承、重写之外，还需要处理构造函数初始化列表和虚函数这两个额外的语法概念：

cpp复制#include <iostream>
#include <string>
using namespace std;

class Person {
protected:
    string name;
    int age;
public:
    Person(string name, int age) : name(name), age(age) {}
    virtual void introduce() {
        cout << "我叫" << name << "，今年" << age << "岁。" << endl;
    }
    virtual ~Person() {}
};

class Student : public Person {
protected:
    string studentId;
    string className;
public:
    Student(string name, int age, string studentId, string className)
        : Person(name, age), studentId(studentId), className(className) {}
    void introduce() override {
        Person::introduce();
        cout << "我是一名学生，学号是" << studentId << "，班级是" << className << "。" << endl;
    }
};

C++的初始化列表是对构造过程更细粒度的控制。Java和Python里super(name, age)是构造方法体内第一条语句，而C++允许你在进入构造方法函数体之前，就用初始化列表逐个字段初始化。如果你在C++里不用初始化列表，而是直接在构造方法体内赋值，对于普通内置类型结果一样，但涉及引用成员或常量成员时就会编译失败——这些问题现在不懂没关系，等学到C++底层的时候就明白了。

virtual关键字是C++实现多态的命脉。Java和Python中，普通方法天然可以重写，而C++必须显式声明为virtual，否则通过父类指针调用时只会调用父类的版本，子类的重写不会生效。如果你在Java的练习里习惯了直接重写方法，转过来学C++时特别容易在这里栽跟头。

4. 实操落地：完整练习代码与测试演示

4.1 搭建测试入口：用主函数串联所有类

写完四个类之后，最容易被忽视的环节就是测试。很多初学者写完类和对象就觉得自己搞定了，实际上没有测试入口，代码跑不起来，根本不知道设计是否正确。我强烈建议你养成一个习惯：每完成一个类设计练习，都写一个测试主函数，把所有类都实例化一遍，调用它们的方法，观察输出是否符合预期。

以Java为例，测试类大概是这样的：

java复制public class Main {
    public static void main(String[] args) {
        Person person = new Person("张三", 40);
        person.introduce();
        System.out.println("----------");

        Student student = new Student("李四", 18, "20240001", "计算机1班");
        student.introduce();
        student.study();
        System.out.println("----------");

        GraduateStudent graduateStudent = new GraduateStudent("王五", 24, "20230002", "计算机2班", "陈教授", "人工智能");
        graduateStudent.introduce();
        graduateStudent.research();
        System.out.println("----------");

        Teacher teacher = new Teacher("赵六", 35, "T1001", "数据结构");
        teacher.introduce();
        teacher.teach();
    }
}

运行效果应该是层层递进的输出。以GraduateStudent graduateStudent = new GraduateStudent(...)这一行最典型——你创建的是一个GraduateStudent对象，它调用自己类里的introduce()，但方法内部又调用了父类的introduce()，父类的introduce()又调用了Person类的introduce()，最终屏幕上按顺序输出四行信息，从“我叫王五”到“我是一名研究生”，身份信息一层层叠加。这种运行结果正是对继承体系是否建对的有力验证。

4.2 参数传递与对象生命周期的隐藏细节

这里补充一个重要但新手很容易忽略的细节：当你调用new GraduateStudent("王五", 24, "20230002", "计算机2班", "陈教授", "人工智能")时，参数列表中各个参数是怎么在各个类的构造器里流转的？这个问题如果你能完整回答，说明你对对象创建的过程理解才真正到位。

流程是这样的：new触发GraduateStudent构造器 → 构造器接收六个参数 → 第一行super(name, age, studentId, className)调用Student的构造器，其中supervisor和researchField两个参数暂时被搁置在GraduateStudent自己的构造器栈帧里 → Student构造器又执行super(name, age)把name和age传给Person → Person构造器先把name赋值给this.name，age赋值给this.age，然后执行完返回 → 回到Student构造器，接着给this.studentId和this.className赋值 → 执行完返回 → 回到GraduateStudent构造器，给this.supervisor和this.researchField赋值 → 对象创建完成。

整个过程中，父类构造永远在子类构造之前完成，这就是Java和C++中对象初始化的“从根到叶”原则。你能看到，一个看似简单的new操作，内部是一场严格的连锁反应。理解了这个流程，你以后调试“字段为null”的问题会快很多——比如你发现studentId打印出来是null，大概率是Student构造器里漏了赋值这一行，而不是别的地方出了问题。

4.3 将代码扩展到“上”之后的进阶方向

我前面说过，day16分为上下两个部分，上半段主要练类设计、封装和继承。如果你觉得上面的练习还不够过瘾，可以自己提前加一些后半段的改进点，作为进阶挑战：

• 把introduce方法的行为改为运行时动态绑定，写一个方法接收Person类型参数，实际传入Student或GraduateStudent，看最终调用的是哪个类的方法，体会多态的含义。
• 引入一个ResearchAbility接口，让GraduateStudent和Teacher都实现它，各自定义自己的doResearch()实现，看看接口如何让两个毫无继承关系的类拥有同一种能力。
• 尝试使用ArrayList<Person>存储所有角色对象，写一个循环统一调用introduce()，你会发现每行输出都不一样——一种类型被当成另一种类型使用时的动态行为，会刷新你对“类型”的认知。

5. 踩坑经验：面向对象练习中那些不碰一次不会懂的教训

5.1 构造方法重载和“重写”之间的概念混淆

综合练习进行到这里，很多人的脑子开始变成浆糊：构造方法到底能不能重写？先说结论：构造方法只能重载，永远不能重写。子类继承父类时，并不能“覆盖”父类的构造方法，因为构造方法名必须与类名完全一致，你不可能在Student里定义一个名字叫Person的方法。所以子类里的构造方法，要么调用父类的某个构造器（用super），要么编译器自动调用父类无参构造器，但无论如何都不会出现“重写构造器”这种事。

这个混淆的深层原因，是因为初学者容易把“继承”理解成“把父类的所有东西都搬过来”。实际上，子类继承的是父类的成员变量和实例方法，但构造器不是成员方法，它只服务于当前类，负责当前类创建对象时的初始化。所以子类必须自己专门定义一套构造器，并主动配合父类完成初始化任务。

5.2 封装粒度：小心“setter泛滥”和“完全不设setter”两个极端

我在批改代码时最常看到的两个极端。第一个极端是：所有字段一律private，然后不管三七二十一全都配上getter和setter。比如学号、班级、导师，甚至研究方向，全部都提供set方法，结果外部代码想怎么改就怎么改，一个对象的身份信息能被随意篡改到逻辑上完全不合理。第二个极端是：为了避免这种情况，干脆全部字段直接public，封装等于没做，完全背离了OOP的基本要求。

正确的做法是：每个字段是否暴露setter，取决于业务逻辑是否允许该字段在某对象创建后被修改。比如学号、工号这些天然属于“身份标识”的字段，创建后就不应该允许外部随意修改，所以只提供getter，不提供setter。而研究方向这种可能随着课题变化而调整的字段，才需要提供setter。你在这个练习里就应该开始建立这种“按需开放”的封装意识，别等到工作了才让别人帮你纠错。

5.3 测试驱动的思路：先写调用代码，再补实现类

最后一个经验很实用。做这类综合练习时，我喜欢反过来写代码：先把Main里的测试调用写好，也就是先想象出各个类应该长什么样、有哪些方法可用，再回头补充类的实现。这和测试驱动开发（TDD）的思想本质上是相通的，但在初学阶段就有意识地这么写，收益远比想象中更大。

理论上，你写完Main里的new GraduateStudent("王五", 24, ...)这行代码时，即使下面所有类都还没定义，编码工具也会提示你缺少这个类。这时你再去创建Person，然后Student extends Person，最后GraduateStudent extends Student，每一步都因为“被调用而有存在意义”。类结构不再是你凭空设计的空中楼阁，而是被真实的调用需求一点点推着成型。这个顺序上的反转，会让你的面向对象代码结构天然更合理。

6. 三语言对比视角：同一套设计里藏着多少语言差异

6.1 类和对象创建：各语言的关键字与风格差异

我们把Java、Python、C++三者的定义做个横向对比，这不仅能加深对当前练习的理解，也为以后切换语言做储备：

这张表的最后一行尤其有意思。Java和Python的虚方法调用是语言默认行为，构造的对象由垃圾回收器统一管理，开发时几乎不用关心对象生命周期。而C++必须手动控制析构时机，这也导致C++的面向对象代码里需要额外考虑内存安全，virtual虚析构函数就是必修课。你在Java练习里形成的思维模型，到了C++里需要做一次不小的修正。

6.2 继承体系里“自动获得”和“强制实现”的差异

在抽象类或接口尚未出场之前，三语言的继承体系差异没那么大，但有一个细节值得关注：重写方法的“签名兼容性”。Java和C++都要求重写方法的签名（参数列表、返回类型）与父类方法一致，尤其Java，如果你把introduce()的返回类型从void改成String，编译会直接报错。而Python是动态类型语言，解释器不检查返回类型，只有运行时才会暴露问题。

这也是为什么我建议初学者认真学一遍Java或C++再做Python的OOP，或者反过来也行——只有在强类型语言里，你才会被编译器强制要求把方法的签名、继承的层次想清楚。Python太宽容，很多错误要到程序运行到某一行才会“啪”地一下暴雷，对新手反而不友好。

7. 综合练习如何与真实项目衔接

7.1 从练习思维到工程思维的三个转变

做完了day16的综合练习，你是不是觉得“就这么简单的系统，跟实际项目差太远了”？确实，一个真实的校园管理系统不可能只有四个类，还有数据库、前端页面、权限控制、异常处理等等。但我觉得，从练习走向工程，核心不是“更多代码”，而是三套思维转变。

第一是从“能跑”到“好改”。练习题的评分标准往往是输出对不对，但实际开发里，代码可读性和可维护性远比第一次运行的输出重要。你习惯了父子类方法层层叠加的组织方式后，回头你会发现自己改需求时的效率完全不一样——改一个类的字段，其他类自然跟着生效，而不是像脚本那样到处改。

第二是从“精确匹配”到“面向扩展”。练习题的需求是给定的、确定的，但真实世界永远在变。今天支持学生、教师、研究生，明天可能就要支持“外聘讲师”“访问学者”“交换生”。继承体系设计得合理，新增一个子类跟在屁股后面加上就行，主流程代码几乎不用动。

第三是从“关注字段”到“关注行为”。初学者写类时满脑子想的是“它有什么”，而老手会优先想“它能做什么”。一个对象应该是数据和行为的统一体，而不是一个纯数据的结构体。字段只是属性，方法才真正表达了这个对象在系统里的价值。

7.2 继续往后走的建议：把练习做成一个小型项目

如果你把上面的代码完全独立地实现了一遍，接下来我建议不要急着学新语言特性，而是先把这个练习往“项目化”方向扩展一下。比如添加一个ArrayList<Person>用来管理所有角色，写一个简单的菜单循环，让用户输入命令来选择创建哪种角色、打印所有角色列表、按姓名查找等。这样你就在一个面向对象综合练习里，顺便练了集合框架和流程控制的综合应用。

这个扩展练习做完，你会发现“面向对象”三个字开始有了实感。它不再是书本上的抽象概念，而是你每天写代码时下意识思考问题的方式——先想类与类之间的关系，再落笔写具体实现。

8. 关于调试与验证：你的代码真的写对了吗

8.1 验证继承关系的“三行测试法”

这里分享一个经验证非常有效的验证方法，我叫它“三行测试法”。在你的Main里写这样三行代码：

java复制Person p1 = new GraduateStudent("王五", 24, "20230002", "计算机2班", "陈教授", "人工智能");
p1.introduce();

第一行用父类类型接收一个子类对象，第二行调用方法，第三行观察输出。如果输出显示“我叫王五……我是一名学生……我是一名研究生”，说明重写机制生效了，继承体系正确；如果只输出了Person的那一行，说明你的方法重写可能没有生效（C++里就要检查virtual），或者你忘记加@Override了。这个方法能快速定位问题是出在继承结构还是出在多态机制上。

8.2 构造器导致的常见错误速查

这里把综合练习中构造器相关的高频问题整理成一张速查表，方便你自查：

这张表我建议你截图收藏，或者抄在笔记本上。虽然平时不一定会遇到所有问题，但每次遇到都回来看一眼，很快就能养成“构造器问题先查子类有没有正确调super”的排查直觉。

8.3 给自己的代码做一次“设计审查”

代码写完能跑通之后，不要急着做下一题，花五分钟做一次设计审查，问自己几个问题：

• 父类Person里的字段和方法，是不是每个子类都真的需要？有没有哪个字段只被某一个子类用到？
• 有没有出现两个子类定义了大量相同方法的情况？如果有，这个公共逻辑是不是应该上移到父类？
• 所有字段的访问控制级别是否合理？子类可以随意修改父类继承下来的字段吗？
• 如果现在要新增一种角色，比如“辅导员”，需要改动哪些代码？如果改动超过了新建一个类加几行调用代码，说明设计还需要调整。

这些问题没有标准答案，但思考过一次之后，你设计的代码会肉眼可见地变好。这比多刷十道题都管用。

9. day16之后怎么继续提升

聊到最后，我还是想说说怎么把这节课吃得透透的。我个人当时带班带下来的经验是，day16是面向对象学习的一个分水岭——练好它，你会觉得“类的设计”不再神秘；偷懒跳过，你会在学多态、抽象类、接口的时候反复回头补课。如果你已经顺利走完了上面这套流程，建议用下面三个方向继续加餐：

把练习里的继承层次再往下扩一层。比如在GraduateStudent下面加一个PhDStudent（博士生），体验一下三级继承的写法，看看构造器链要怎么串联，字段怎么逐级积累。

把练习里的所有introduce方法改成“统一接口遍历调用”，建一个Person[] persons数组，里面装普通学生、研究生、教师各一个，循环调用，观察多态的效果。这是你从“继承”走向“多态”的天然桥梁。

把练习代码用Git管理起来，提交一次day16的版本。等学到后面你甚至可以翻回来看，当初写的类结构有什么不合理的地方，这种“回头对照”的复习方式，对构建完整的知识体系大有帮助。