Java面向对象核心：继承、super、this与抽象类一次讲透

学Java要是没把继承、super、this、抽象类这几个概念弄明白，后面但凡涉及到类设计、框架源码、设计模式的代码，都会读得很吃力。这不是夸张——我见过太多人循环数组写得飞起，一到继承这里就开始犯迷糊：super能不能不写？this()和super()为什么不能同时出现？抽象类到底能不能new？

这篇文章就是要把这几个问题一次说透。我会从最朴素的代码例子出发，讲清楚继承到底解决了什么问题、this和super各自扮演什么角色、抽象类和普通类差在哪、以及抽象类和接口该怎么选。适合正在学JavaSE面向对象这一章的初学者，也适合学过一遍但总是“道理都懂、代码写错”的同学。后半部分我还会放一个完整的员工管理Demo，带你把知识点串起来跑一遍。

1. 继承：为什么说它是面向对象复用的基石

1.1 没有继承时，代码是怎么“膨胀”的

很多教材一上来就甩出继承的定义，说继承是“子类拥有父类的属性和方法”。这句话背下来容易，但你不一定真能感受到它解决的是什么问题。我习惯先让学员写一个“没有继承”的版本，体验一下什么叫痛。

假设现在要设计三个类：学生类、教师类、辅导员类。它们都有的东西是姓名、年龄、工号或学号，都要吃饭、睡觉、自我介绍。你写第一版学生会觉得没什么，写第二版教师类开始觉得重复，写第三版辅导员类的时候，光标闪烁半天，你已经意识到自己就是在复制粘贴。

复制粘贴三个类，表面上没什么问题。但需求一变就露馅了：比如“自我介绍”要求增加一条“所属院系”，你需要同时改三个类；改的时候少改了一个类，编译不报错、测试测不出来，直到上线后某一天用户才发现教师自我介绍里没有院系信息。这就是代码膨胀的典型代价——重复代码越多，维护成本越高，出错的概率越大。

继承解决的就是这个问题：把公共的属性和行为抽取到一个父类里，让多个子类复用。学生、教师、辅导员都从同一个父类派生，父类里改一次，所有子类通通生效。

1.2 extends语法与继承的关键规则

Java里继承用extends关键字，语法很简单：

class Person { String name; int age; void introduce() { System.out.println("我叫" + name + "，今年" + age + "岁"); } } class Student extends Person { String studentId; }

这里Student不需要再声明name和age，也不需要再写introduce()，因为继承了Person。你直接new一个Student，就能调用name、age和introduce()。

但有几个规则，初学者必须刻进脑子里：

第一，Java的类只支持单继承。一个类只能有一个直接父类，不能写class A extends B, C。这是Java设计上的取舍，为了避开多继承带来的菱形问题。菱形问题简单说就是：如果B和C都有同一个方法d()，D同时继承B和C，那D到底该用谁的d()？Java干脆禁止类的多继承，从根源上消灭这个问题。

第二，构造方法不会被继承。父类的构造方法是在子类构造过程中被调用的，但子类并不会自动获得同名的构造方法。很多新手以为父类有带参构造，子类就可以直接new出来，结果编译报错找不到构造方法，原因就在这。

第三，父类的私有成员（private修饰的）子类访问不到。这个“访问不到”不是说子类没有继承到，而是子类对象里确实有这份数据，只是没有直接访问权限。你需要通过父类提供的public或protected方法去间接访问。这一点后面讲super的时候还会再提。

1.3 不同的继承方式该怎么选

继承不是只有“一个类继承另一个类”这一种形态。在实际代码里，继承方式大致分这么几种：

单继承是最常见的，一个子类对应一个父类，比如Dog继承Animal。多层继承则是A继承B、B继承C，形成一条链。比如经理类继承员工类，员工类继承人类，这种层次结构只要不深，可读性还是很好的。问题是很多初学者容易把层级拉得特别长，A继承B，B继承C，C继承D，最后整个类体系变得像一口深井，调试的时候想找一个字段的声明位置都得翻半天。

接口多实现是另一种“继承”方式，它规避了Java单继承的限制。一个类可以实现多个接口，接口里只定义行为契约，不关注具体的属性。所以有一种经验总结说：能用接口表达的“能力”，不要硬塞进继承体系里。比如“会飞”是一种能力，飞鸟继承动物同时实现飞行接口，飞机不继承动物但也能实现飞行接口，这样设计就灵活得多。

横向对比一下其他语言，也能加深理解。JavaScript的继承走的是原型链，本质上是通过对象的隐式原型逐级向上查找属性；Python支持多继承，但引入了MRO（方法解析顺序）来处理菱形问题，理解成本比Java高不少。Java选择单继承+接口多实现，算是平衡了灵活性和复杂度。作为初学者，先把Java这一套吃透就够了，不用急着横向比较。

2. this和super：一对容易混淆的“上下级”

2.1 this的三种典型用法

this在Java里代表的是“当前对象”的引用。注意，它只能出现在实例方法、构造方法这些和对象相关的场景里，static方法里不能用this，因为static不依赖对象存在。

第一种用法是区分局部变量和成员变量。最常见的场景就是构造方法参数命名：

public class Person { private String name; public Person(String name) { this.name = name; } }

方法参数name和成员变量name重名了，Java的局部变量优先级更高，直接用name就取不到成员变量。this.name = name; 的意思就是“把参数name赋值给当前对象的name成员变量”。有人问：变量名不一样不就行了吗，为什么一定要用this？确实可以，但制造大量非标准命名的变量（比如pName、nName）会让代码越写越别扭，不如保持名字一致然后用this来区分。

第二种用法是调用本类的成员方法。比如在一个类里写this.showInfo()和直接写showInfo()，效果是一样的，this可以省略。我建议初学者先不要省略，写一段时间之后习惯了再省略也不迟。

第三种用法是关键：this()调用本类的其他构造方法。注意，this()只能写在构造方法的第一行，并且不能和super()同时出现。它解决的问题是构造方法之间的代码复用。

public class Person { private String name; private int age; public Person() { this("匿名", 0); } public Person(String name, int age) { this.name = name; this.age = age; } }

这样new Person()的时候，无参构造会去调用带参构造，初始化逻辑只写一遍。

2.2 super的三种典型用法

super代表的是“父类的空间引用”。它做三件事：访问父类成员变量、调用父类成员方法、调用父类构造方法。

访问父类成员变量和成员方法，通常发生在子类重写了父类方法、或者子类定义了和父类同名成员的时候。你想调用父类的版本，不加super就会递归调用子类自己的方法，造成逻辑错误：

class Person { void introduce() { System.out.println("我是一个人"); } } class Student extends Person { void introduce() { super.introduce(); // 先调用父类的方法 System.out.println("我也是一名学生"); } }

如果你在子类introduce()里不写super.introduce()，直接调用introduce()，那就会无限递归——自己调自己，直到栈溢出。

super的第三种用法，也就是super()调用父类构造方法，是重中之重。任何一个子类构造方法，编译器都会在它的第一行默认插入super()，哪怕你没写。这就是为什么父类必须有一个无参构造方法，否则子类编译就会报错。如果父类只有带参构造，子类就必须显式调用super()并传入参数。

2.3 this和super对比速查表

这里我直接把两者放在一起对比，方便你随时查阅：

有一句话特别能帮助记忆：this是向上追溯的，super是直接向上看的。this找成员时先看自己类里有没有，没有再去父类里找；super的意图更明确——我就是要找父类的那个成员，别在本类里磨蹭。

2.4 子类构造方法的隐藏调用链

这一节是考试和面试的高频考点，也是很多新手真正开始理解面向对象的地方。

先看一个经典报错：你定义了一个父类，只写了带参构造方法，然后写了一个子类，子类构造方法什么都没写。编译时你会看到这样的错误信息：Implicit super constructor Person() is undefined. 必须显式调用父类的某个构造方法。

原因是这样的：子类构造方法第一行默认是super()，它去调用父类的无参构造。但你的父类定义了一个带参构造之后，编译器就不再帮你生成那个默认的无参构造了。于是super()找不到目标，直接报错。

解决方案有两个：要么给父类显式补一个无参构造，要么在子类构造方法第一行写super(参数)，手动指定调用父类哪个构造方法。

再往深一层看，Java的对象创建过程是有顺序的。你new一个子类对象，执行序列是这样的：

class Person { public Person() { System.out.println("父类构造"); } } class Student extends Person { public Student() { super(); // 手动写上和不写，效果一样 System.out.println("子类构造"); } } public class Demo { public static void main(String[] args) { new Student(); } }

运行结果是先打印“父类构造”，再打印“子类构造”。原因就是子类构造方法的第一行调用了父类构造方法，父类的初始化永远先于子类。这个顺序看起来简单，但很多考生一写多层继承就懵：A继承B，B继承C，你new A()，打印顺序是C的构造方法、B的构造方法、A的构造方法，一层一层往外执行，像剥洋葱一样。

3. 抽象类：把“不完整”变成设计优势

3.1 抽象类和普通类的本质区别

说到继承，就得提抽象类。为什么要引入抽象类？我习惯用一个生活中的例子来讲：你设计一个“动物类”，里面有一个“叫”的方法。问题是，不管你怎么写方法体，写“动物在叫”都是废话——动物这个概念太泛了，真实的动物一定是具体的猫、狗、鸟。你不希望有人new一个“动物”对象出来，因为那没有意义。

抽象类就是干这个的。用abstract修饰的类叫抽象类，抽象类里可以定义抽象方法。抽象方法只有方法声明，没有方法体：

abstract class Animal { String name; public Animal(String name) { this.name = name; } public abstract void sound(); }

看这段代码，Animal类有个明确的属性name，有个构造方法，但sound()方法没有大括号，只有分号，这就是抽象方法。它告诉所有子类：“凡是继承我的，都必须自己实现sound()”。

这里有一个对比表格，把抽象类和普通类的区别列清楚：

特别注意，抽象类虽然不能new，但它有构造方法。这个构造方法存在的意义是给子类调用，模拟项目里很多新手问：“抽象类都不能创建对象，要构造方法干嘛？”答案是：子类构造方法里会调用super()，你new的是子类对象，但对象的父类部分需要初始化。

抽象类的子类分两种：如果子类实现了父类全部抽象方法，它就是普通类，可以被实例化；如果子类只实现了一部分，甚至一个都没实现，那这个子类也必须是抽象类，继续把未实现的抽象方法往下传。

3.2 抽象类与接口：什么时候用哪个

这是六月Java面试里被问爆的问题，我直接列一个完整的对比：

核心判断标准就一句话：狗继承动物类是合理的，因为狗“是一种”动物；但让狗实现一个“飞行能力”接口就不合理，因为它不是“能飞”的。反过来，飞机实现飞行接口是合理的，但飞机去继承动物类就荒谬了。所以抽象类描述的是is-a关系，接口描述的是has-a行为，两者服务的目标不一样。

我见过不少初学者，一说要抽象就立刻建接口，结果接口里塞了一堆默认方法，越写越臃肿。判断标准其实很简单：如果你的多个类之间有明显公共的属性和代码逻辑，用抽象类；如果你只是要给一批互不相干的类统一行为规范，用接口。还有一种常见组合是：用抽象类做公共骨架，同时实现接口约定行为，这在框架源码里极其常见。

3.3 抽象类的经典应用：模板方法

抽象类在实战里最经典的应用是模板方法设计模式。所谓模板方法，就是抽象类里把算法的骨架写死，把可变的部分定义成抽象方法交给子类去实现。这样代码复用了骨架，又保留了扩展的空间。

举个例子。写一个支付流程：不管微信支付、支付宝支付还是银联支付，流程都是固定的——下单、验证库存、扣款、发送通知。扣款方式不同，但流程骨架完全一样。抽象类可以这样设计：

abstract class Payment { // 模板方法，用final防止子类修改骨架 public final void pay() { step1CreateOrder(); step2Verify(); step3Deduct(); step4Notify(); } private void step1CreateOrder() { System.out.println("创建订单"); } private void step2Verify() { System.out.println("验证库存"); } private void step4Notify() { System.out.println("发送通知"); } abstract void step3Deduct(); } class WeChatPay extends Payment { @Override void step3Deduct() { System.out.println("微信扣款"); } }

在这个例子里，整个支付流程的顺序已经由抽象类定死了，子类只需要关心“怎么扣款”这一件事。这就是抽象类最大的价值：它把设计者的意图明确表达出来，任何继承它的子类，都必须遵守这份“约定”。

4. 封装、继承、多态：面向对象三大特性如何配合

4.1 三大特性各自管什么

面向对象三大特性，封装、继承、多态，经常被一起提到，但很多初学者只记住了名字，没想明白它们之间的关系。我打个比方：封装是“关起门来做自己的事”，继承是“站在巨人的肩膀上做事”，多态是“同一个指令，不同的人做不同的事”。

封装负责隐藏内部细节，对外只暴露必要的接口。它的核心手段是访问权限控制，private字段配public方法。继承负责抽取公共逻辑，建立类之间的层次关系，它的核心机制就是前面讲的extends。多态负责让同一个方法调用呈现出不同的行为，它的前提有三个：有继承关系、子类重写了父类方法、父类引用指向子类对象。

这三个特性不是孤立的。继承里如果没有封装配合，父类所有的字段都直接对外开放，子类可以随意修改，那继承体系很快就会被改乱。多态如果没有继承作为前提，父类引用根本不可能指向子类对象，更谈不上动态绑定。

4.2 继承是多态的前提

多态的底层机制，说穿了就是两个字：重写和绑定。方法的重写发生在继承关系里，子类用相同的方法签名重新实现父类的方法。而Java在运行时会根据对象的实际类型，动态决定调用哪个版本的方法——这个叫动态绑定，也叫运行时多态。

举个例子，下面的代码用Animal引用指向Dog对象：

class Animal { void sound() { System.out.println("动物发出声音"); } } class Dog extends Animal { @Override void sound() { System.out.println("汪汪"); } } public class Demo { public static void main(String[] args) { Animal a = new Dog(); a.sound(); // 输出：汪汪 } }

编译时期，编译器看到的是a的类型是Animal，但运行时期，JVM实际创建的是Dog对象，所以调用的是Dog重写后的sound()。这就是为什么说多态是“编译看左边，运行看右边”。

为什么需要多态？最实际的收益是代码的可扩展性。如果写个方法，参数是Animal类型，那么任何Animal的子类都可以传进去，不必为每一种动物单独写一个方法。以后新增一个Cat类，调用方的代码一行都不用改，完全符合开闭原则——对扩展开放，对修改关闭。这就是继承支撑多态，多态反哺设计灵活性的完整闭环。

4.3 一个贯穿三者的代码例子

我把三大特性在一个例子里串一遍。需求是写一个动物园系统，能接收各种动物，统一让它们叫唤。

abstract class Animal { private String name; // 封装：私有属性 public Animal(String name) { this.name = name; } public String getName() { // 通过公共方法访问 return name; } public abstract void sound(); // 抽象方法，交给子类实现 } class Dog extends Animal { public Dog(String name) { super(name); // super调用父类构造 } @Override public void sound() { System.out.println(getName() + "：汪汪"); } } class Cat extends Animal { public Cat(String name) { super(name); } @Override public void sound() { System.out.println(getName() + "：喵喵"); } } public class Zoo { public static void makeSound(Animal animal) { // 多态：接收Animal，任何子类都能进 animal.sound(); } public static void main(String[] args) { makeSound(new Dog("旺财")); makeSound(new Cat("咪咪")); } }

这30行代码，封装体现在name是private的、通过getName访问；继承体现在Dog和Cat都继承Animal，复用了name属性和构造逻辑；多态体现在makeSound方法接收的是Animal类型，却调用了各自的sound()方法；而整个设计能在运行期正确地分派行为，靠的是Animal被设计为抽象类，并通过super把构造参数传递上去。

初学者研究这个例子，比背十遍概念管用得多。三大特性全部落到了代码层面，缺一个这个例子都不成立。

5. 实操：从零编写员工管理系统的继承结构

5.1 需求设计与类结构规划

前面讲概念，这一节做一个完整的实操。很多初学者看完概念还是不知道该怎么下手，我直接模拟一个新员工管理系统的开发过程。

需求是这样的：公司有三种员工——普通员工、开发人员、经理。所有员工都有姓名、工号、基本工资这些公共属性，都有“工作”的行为，但工作内容各不相同。另外，公司有一个统一的年终奖计算逻辑，计算方式在员工之间完全不一样。

分析这个需求，公共属性是复用点，适合抽取到父类；“工作”行为虽然名字相同但实现不同，适合定义成抽象方法；年终奖计算也是各干各的，同样是抽象方法。于是类结构就清晰了：

• 抽象类Employee：公共属性name、id、salary，公共方法showInfo()，抽象方法work()和calculateBonus()
• 类Developer：继承Employee，增加属性linesOfCode，实现work()和calculateBonus()
• 类Manager：继承Employee，增加属性teamSize，实现work()和calculateBonus()
• 测试类Main：创建对象，验证继承、super、抽象类、多态的全部知识点

5.2 完整代码：抽象父类与两个子类

先写抽象父类：

abstract class Employee { private String name; private int id; protected double salary; public Employee(String name, int id, double salary) { this.name = name; this.id = id; this.salary = salary; } public String getName() { return name; } public int getId() { return id; } public void showInfo() { System.out.println("姓名：" + name + "，工号：" + id); } public abstract void work(); public abstract double calculateBonus(); }

注意我把salary设为protected，这个细节很关键。private对子类不可见，子类的calculateBonus()里直接访问salary会编译报错；protected允许子类访问，但不对外部开放，兼顾了封装和继承。这正是第三部分讲的“受保护权限是父类给子类开的专属通道”。

再写两个子类：

class Developer extends Employee { private int linesOfCode; public Developer(String name, int id, double salary, int linesOfCode) { super(name, id, salary); // 必须显式调用，因为父类没有无参构造 this.linesOfCode = linesOfCode; } @Override public void work() { System.out.println(getName() + "正在写代码，产出了" + linesOfCode + "行代码"); } @Override public double calculateBonus() { return salary * 0.2 + linesOfCode * 0.5; } } class Manager extends Employee { private int teamSize; public Manager(String name, int id, double salary, int teamSize) { super(name, id, salary); this.teamSize = teamSize; } @Override public void work() { System.out.println(getName() + "正在管理" + teamSize + "人团队"); } @Override public double calculateBonus() { return salary * 0.5 + teamSize * 1000; } }

这两段代码用到了几乎前面所有的知识点：extends建立继承关系；super(name, id, salary)调用父类带参构造；salary因为protected所以子类能直接用；两个抽象方法全部被重写，子类才能成为一个普通类。

5.3 测试运行与设计复盘

最后写测试类：

public class Main { public static void main(String[] args) { Employee emp1 = new Developer("小张", 1001, 18000, 8000); Employee emp2 = new Manager("小李", 1002, 25000, 8); test(emp1); test(emp2); } public static void test(Employee employee) { employee.showInfo(); employee.work(); System.out.println("年终奖：" + employee.calculateBonus()); System.out.println("----------------------"); } }

运行结果：

姓名：小张，工号：1001 小张正在写代码，产出了8000行代码 年终奖：7600.0 ---------------------- 姓名：小李，工号：1002 小李正在管理8人团队 年终奖：20500.0 ----------------------

这个结果里最有价值的部分，是test()方法的参数类型是Employee。按普通思维，你可能想写两个方法，一个接收Developer，一个接收Manager。但有了抽象类和多态，只需要写一个方法，不管是哪个子类对象进来都能处理。以后再加一个HR类，test()方法一行代码都不用改。

复盘这个设计：抽象类Employee定义了整个体系的规范，不能实例化，但能接收所有子类对象；super解决了带参构造方法的传递问题；this.name = name解决了参数和成员变量重名问题；protected权限让salary在不完全暴露的情况下被子类使用了。二十多行代码，把这一整章的知识点全部串起来了。

6. 常见问题与排查技巧实录

6.1 高频报错速查表

我在带新人过程中，积累了这么一张高频报错速查表，基本都是初学者碰到过的：

这张表我建议直接截屏存起来。每个报错在初学阶段至少会遇到两次，第一次查表，第二次就能背下来了。

6.2 几条独家避坑经验

最后分享几条课堂上看不到、但实战中特别重要的经验。

第一，继承层次尽量控制在三层以内。类A继承类B，B继承C，这种三层还能看清，超过三层以后，你会发现一个方法不知在哪个父类里定义，需要IDE的“打开声明”功能到处跳。遇到这种结构，优先考虑用组合代替继承——把公共逻辑抽到一个类里，用字段引用的方式复用，而不是一味的extends。

第二，构造方法里不要调用可以被重写的方法。举个例子，父类构造方法里调用了this.sound()，而子类重写了sound()，那new子类对象时，父类构造阶段就会调用到子类的方法，而此时子类的字段还没初始化，轻则得到null，重则抛出NullPointerException。Java创建的对象的初始化顺序非常严格，父类构造在前，子类字段初始化在后，这个顺序决定了这种调用极其危险。改成在构造里调用private方法，或者干脆把所有复杂逻辑放到子类构造完成后显式调用。

第三，设计父类时，把权限放对位置是一种智慧。默认情况下，成员变量用private，仅供子类使用的用protected，本类自己用、不希望别人碰的也用private。不要一上来就把所有字段设为public，等到架构膨胀时再来收拾烂摊子，付出的成本会成倍增加。

第四，写抽象类之前，先回答自己一个问题：这个类的子类们，是否真的共享了大量公共代码？如果只是需要一个统一的类型，用接口就够了。抽象类不是万能的，用得太多反而会造成继承层级过重。这里的原则可以简化为：有代码要复用，用抽象类；只需要定规范，用接口。

我自己在实际教学里的感受是：继承、super、this、抽象类这四个知识点，最难的不是某个独立概念，而是它们在同一个代码文件里交错出现时的理解。所以每次带新人，我都建议先画一张类关系图，把谁是父类、谁是子类、哪个是抽象类标清楚，然后再去看代码。对着图读代码，五分钟就能理清思路；不画图纯靠脑补，代码一多必乱。

如果你现在还卡在这几个概念上，别慌。先用今天文章里的员工管理系统例子自己敲一遍，敲完以后自己加一个HR类、加一个计算年终奖的新规则，跑通之后再看下一篇的内容。动手了，就真的懂了。