Java抽象类与接口：面试高频考点全解析
目录
5.3 重写（Override）vs 重载（Overload）
本文深入解析Java中抽象类与接口的核心区别与应用场景。抽象类作为"半成品老爸"，通过构造方法、成员变量和完整方法实现代码复用，适用于模板方法模式；接口则作为"能力证书"，通过default方法和多实现机制定义行为规范，适用于策略模式。文章详细对比了两者在方法实现、构造方法、成员变量三个维度的差异，并分析了JDK8+版本中接口的新特性。最后指出：抽象类解决代码复用问题（is-a关系），接口解决行为规范问题（can-do关系），二者在面向对象设计中相辅相成。掌握这些区别有助于写出更灵活、可维护的Java代码。
Java 抽象类与接口：从入门到面试高频考点深度解析
一、前言：为什么总搞混抽象类和接口？
如果你正在准备 Java 面试，或者刚学到面向对象进阶部分，"抽象类和接口有什么区别"这个问题你一定绕不过去。
说实话，这个问题看起来简单，但真要答到点子上，很多工作一两年的程序员都说不清楚。最常见的一种回答是："抽象类可以有方法实现，接口只能有抽象方法。"——这个答案在 JDK 8 之前勉强能拿及格分，放到现在直接不及格。
我写这篇文章，就是想用最直白的方式，把抽象类和接口的本质区别、语法细节、使用场景、面试套路一次性讲透。文章会很长，但我会尽量用"说人话"的方式，配合大量可运行的代码示例，让你看完不仅知道"是什么"，更知道"为什么"和"怎么用"。
二、抽象类：半成品的老爸
2.1 什么是抽象类？
抽象类，关键词在"抽象"两个字。什么叫抽象？就是还没做完、不能直接用的东西。
在 Java 里，一个类被 abstract 修饰，它就变成了抽象类。抽象类不能被实例化（不能 new），但它可以包含：
-
普通成员变量
-
普通方法（有完整方法体）
-
抽象方法（没有方法体，只有声明）
-
构造方法
-
常量
核心定位：抽象类是"半成品"，它提取了多个子类的共性代码，同时强制子类实现某些特定行为。
2.2 抽象类的语法
// 抽象类用 abstract 修饰
abstract class Animal {
// 普通成员变量：每个子类对象都有自己的一份
protected String name;
protected int age;
// 常量
static final String KINGDOM = "Animalia";
// 构造方法：抽象类可以有构造方法！
Animal(String name, int age) {
this.name = name;
this.age = age;
System.out.println("Animal 构造方法执行");
}
// 普通方法：有完整实现，子类直接继承复用
void sleep() {
System.out.println(name + " 闭上眼睛睡觉...");
}
// 抽象方法：没有方法体，子类必须实现
abstract void makeSound();
// 普通方法也可以调用抽象方法（模板方法模式）
void dailyRoutine() {
sleep();
makeSound(); // 具体叫什么，由子类决定
}
}
2.3 子类继承抽象类
class Dog extends Animal {
Dog(String name, int age) {
super(name, age); // 必须调用父类构造方法
}
@Override
void makeSound() {
System.out.println(name + "：汪汪汪");
}
}
class Cat extends Animal {
Cat(String name, int age) {
super(name, age);
}
@Override
void makeSound() {
System.out.println(name + "：喵喵喵");
}
}
测试代码：
public class Test {
public static void main(String[] args) {
// Animal a = new Animal("test", 1); // ❌ 编译错误！抽象类不能实例化
Dog dog = new Dog("旺财", 3);
dog.sleep(); // 继承来的：旺财 闭上眼睛睡觉...
dog.makeSound(); // 自己实现的：旺财：汪汪汪
Cat cat = new Cat("咪咪", 2);
cat.dailyRoutine();
// 输出：
// 咪咪 闭上眼睛睡觉...
// 咪咪：喵喵喵
}
}
2.4 抽象类的构造方法：一个容易踩的坑
很多人以为抽象类不能 new，所以它没有构造方法。这是错的。
抽象类有构造方法，而且子类必须调用它。
abstract class Father {
String name;
// 显式定义了有参构造
Father(String name) {
this.name = name;
System.out.println("Father 构造执行");
}
}
class Son extends Father {
int age;
// 如果这里什么都不写，编译器会生成默认构造：
// Son() { super(); }
// 但 Father 没有无参构造！编译报错！
Son(String name, int age) {
super(name); // ✅ 必须显式调用父类有参构造
this.age = age;
System.out.println("Son 构造执行");
}
}
核心规则：
-
子类构造方法的第一行，默认是
super()（调用父类无参构造） -
如果父类（即使是抽象类）只有有参构造，没有无参构造，子类必须显式写
super(参数) -
抽象类的构造方法就是为了给子类初始化继承来的成员变量用的
2.5 抽象类继承抽象类：可以"赖账"
这是一个面试常考点：抽象类的子类如果是抽象类，它可以不实现父类的抽象方法。
abstract class Grandpa {
abstract void method1();
abstract void method2();
}
// Father 也是抽象类，它可以继续"拖欠"
abstract class Father extends Grandpa {
@Override
void method1() {
System.out.println("Father 实现了 method1");
}
// method2 没实现，没问题！编译通过 ✅
}
// Son 是普通类，必须把所有抽象方法都实现
class Son extends Father {
@Override
void method2() {
System.out.println("Son 实现了 method2");
}
}
规则总结：
-
普通类
extends抽象类 → 必须实现所有抽象方法（或者自己也声明为抽象类） -
抽象类
extends抽象类 → 可以实现一部分、不实现一部分，全部不实现也行
三、接口：纯规范，能力的标签
3.1 什么是接口？
如果说抽象类是"半成品老爸"，那接口就是"能力证书"。
接口用 interface 关键字定义，它完全面向规范：
-
接口中的方法（JDK 8 之前）都是抽象的，没有方法体
-
接口中的变量都是常量
-
接口没有构造方法
-
接口不能被实例化
核心定位：接口定义的是"你能做什么"（can-do），而不是"你是什么"（is-a）。
3.2 接口的语法演进（重点）
接口在 Java 不同版本中有很大变化，这是现代面试必考的。
JDK 7 及以前：纯抽象
interface USB {
// 隐式 public static final
int VERSION = 3;
// 隐式 public abstract
void connect();
void transferData();
}
这时候的接口就是"纯规范"，所有方法都没方法体，实现类必须全部实现。
JDK 8：引入 default 和 static 方法
interface Animal {
// 抽象方法：实现类必须实现
void makeSound();
// default 方法：有默认实现，实现类可以不重写
default void sleep() {
System.out.println("闭上眼睛睡觉...（默认版）");
}
// static 方法：属于接口本身，直接调用
static void info() {
System.out.println("这是 Animal 接口");
}
}
为什么加 default 方法？
为了兼容老代码。比如 Java 集合框架的 Collection 接口，如果要在接口里加一个新方法，以前所有实现类都会编译报错。有了 default，可以给个默认实现，不强制所有实现类修改。
class Dog implements Animal {
@Override
public void makeSound() {
System.out.println("汪汪汪");
}
// sleep() 用默认的，不用写
}
class Cat implements Animal {
@Override
public void makeSound() {
System.out.println("喵喵喵");
}
// Cat 想用自己的方式睡觉，可以重写
@Override
public void sleep() {
System.out.println("猫蜷缩成一团睡觉");
}
}
JDK 9：引入 private 方法
interface MyInterface {
default void methodA() {
commonLogic();
System.out.println("A");
}
default void methodB() {
commonLogic();
System.out.println("B");
}
// private 方法：辅助 default 方法复用代码
private void commonLogic() {
System.out.println("公共逻辑");
}
}
3.3 接口的多实现
这是接口最大的优势：一个类可以实现多个接口。
interface Flyable {
void fly();
}
interface Swimmable {
void swim();
}
// 鸭子：既能飞又能游
class Duck implements Flyable, Swimmable {
@Override
public void fly() {
System.out.println("鸭子扑腾翅膀飞");
}
@Override
public void swim() {
System.out.println("鸭子划水游泳");
}
}
Java 类是单继承的（一个类只能有一个爹），但接口是多实现的（一个类可以有多个能力标签）。这解决了单继承的局限性。
四、核心区别深度对比：三个维度+代码实证
下面从方法实现、构造方法、成员变量三个维度，用具体代码说明差异。
4.1 方法实现
抽象类：完整方法和抽象方法自由组合
抽象类的核心价值之一就是代码复用。把子类通用的逻辑写在抽象类里，子类直接继承。
abstract class BankAccount {
protected double balance;
protected String accountId;
BankAccount(String accountId, double balance) {
this.accountId = accountId;
this.balance = balance;
}
// 完整方法：所有子类通用，直接复用
void deposit(double amount) {
if (amount > 0) {
balance += amount;
System.out.println("存入 " + amount + "，余额：" + balance);
}
}
// 完整方法：查询余额
double getBalance() {
return balance;
}
// 抽象方法：取款逻辑不同（储蓄卡不能透支，信用卡可以）
abstract void withdraw(double amount);
}
class SavingsAccount extends BankAccount {
SavingsAccount(String accountId, double balance) {
super(accountId, balance);
}
@Override
void withdraw(double amount) {
if (balance >= amount) {
balance -= amount;
System.out.println("储蓄卡取款 " + amount + "，余额：" + balance);
} else {
System.out.println("余额不足！");
}
}
}
class CreditAccount extends BankAccount {
double creditLimit; // 信用额度
CreditAccount(String accountId, double balance, double limit) {
super(accountId, balance);
this.creditLimit = limit;
}
@Override
void withdraw(double amount) {
if (balance + creditLimit >= amount) {
balance -= amount;
System.out.println("信用卡取款 " + amount + "，余额：" + balance);
}
}
}
抽象类的优势体现：deposit() 和 getBalance() 只写一次，SavingsAccount 和 CreditAccount 都直接继承使用。如果不用抽象类，两个子类都要重复写存款和查询逻辑。
接口：从纯规范到默认实现
interface Drawable {
// 抽象方法：必须实现
void draw();
// default 方法：给默认实现
default void setColor(String color) {
System.out.println("设置颜色为：" + color);
}
// static 方法：工具方法
static void resetCanvas() {
System.out.println("重置画布");
}
}
class Circle implements Drawable {
@Override
public void draw() {
System.out.println("画一个圆");
}
// setColor() 用默认的
}
class Rectangle implements Drawable {
@Override
public void draw() {
System.out.println("画一个矩形");
}
@Override
public void setColor(String color) {
System.out.println("矩形特殊上色：" + color);
}
}
public class Test {
public static void main(String[] args) {
Circle c = new Circle();
c.draw(); // 画一个圆
c.setColor("红色"); // 设置颜色为：红色（默认实现）
Rectangle r = new Rectangle();
r.setColor("蓝色"); // 矩形特殊上色：蓝色（自己重写的）
Drawable.resetCanvas(); // 重置画布（静态方法）
}
}
关键区别：
-
抽象类的普通方法是"强制性继承"，子类自动拥有
-
接口的
default方法是"可选项"，子类可以选择用默认的，也可以重写
4.2 构造方法
抽象类：有构造方法
abstract class Person {
String name;
int age;
// ✅ 抽象类有构造方法
Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("Person 构造执行");
}
}
class Teacher extends Person {
String subject;
Teacher(String name, int age, String subject) {
super(name, age); // 调用抽象类构造
this.subject = subject;
System.out.println("Teacher 构造执行");
}
}
// 测试
new Teacher("张三", 30, "数学");
// 输出：
// Person 构造执行
// Teacher 构造执行
为什么抽象类需要构造方法？
因为抽象类可以有成员变量，这些变量需要初始化。子类通过 super() 调用父类构造来完成初始化。虽然抽象类自己不能 new，但它的构造方法是给子类用的。
接口：没有构造方法
interface USB {
// ❌ 接口不能有构造方法
// USB() {} // 编译报错！
void connect();
}
class UDisk implements USB {
String brand;
// 子类构造只调 Object 的构造
UDisk(String brand) {
// super(); // 隐式调用 Object()
this.brand = brand;
}
@Override
public void connect() {
System.out.println(brand + " U盘已连接");
}
}
为什么接口没有构造方法？
因为接口没有需要初始化的"对象状态"。接口里的变量都是 public static final 常量，编译时就确定了，不需要构造方法来初始化。接口只定义行为规范，不持有数据。
4.3 成员变量
抽象类：普通变量 + 常量
abstract class GameCharacter {
// 实例变量：每个对象独立
String name;
int hp;
int mp;
// 类变量
static int totalCharacters = 0;
// 常量
static final int MAX_LEVEL = 100;
GameCharacter(String name) {
this.name = name;
this.hp = 100;
this.mp = 50;
totalCharacters++;
}
abstract void attack();
}
class Warrior extends GameCharacter {
int attackPower; // 战士特有属性
Warrior(String name, int power) {
super(name);
this.attackPower = power;
}
@Override
void attack() {
System.out.println(name + " 挥舞大刀，造成 " + attackPower + " 点伤害");
}
}
class Mage extends GameCharacter {
int magicPower;
Mage(String name, int magic) {
super(name);
this.magicPower = magic;
}
@Override
void attack() {
System.out.println(name + " 释放火球，造成 " + magicPower + " 点魔法伤害");
}
}
测试：
Warrior w1 = new Warrior("亚瑟", 50);
Warrior w2 = new Warrior("吕布", 60);
Mage m1 = new Mage("妲己", 80);
System.out.println(w1.hp); // 100（各自独立）
System.out.println(GameCharacter.totalCharacters); // 3（共享）
System.out.println(GameCharacter.MAX_LEVEL); // 100（常量）
抽象类的成员变量可以是各种类型，子类继承后各自独立（实例变量）或共享（静态变量）。
接口：只能是 public static final 常量
interface Config {
// 以下三种写法完全等价
int MAX_RETRY = 3;
public int MAX_RETRY2 = 3;
public static final int MAX_RETRY3 = 3; // 编译器实际看到的
// ❌ 错误写法
// int count; // 没有初始化，报错
// String name; // 没有初始化，报错
}
class App implements Config {
void doRequest() {
for (int i = 0; i < MAX_RETRY; i++) { // 直接用
System.out.println("第 " + (i+1) + " 次请求");
}
}
}
接口变量的特点：
-
必须初始化（因为是
final） -
通过
接口名.常量名访问（因为是static） -
所有实现类共享同一个值（因为是
static） -
不能被修改（因为是
final）
五、继承与实现规则
5.1 单继承 vs 多实现
abstract class Animal {}
abstract class Machine {}
// ❌ Java 不支持多继承
class RobotDog extends Animal, Machine {}
// ✅ 但可以多实现接口
interface Movable {}
interface Speakable {}
class RobotDog extends Animal implements Movable, Speakable {}
5.2 子类构造与父类构造的关系
这是前面讲过的，再强调一次：
class Father {
Father(String name) {} // 只有有参构造
}
class Son extends Father {
// 如果不写构造，编译器生成：
// Son() { super(); } // ❌ Father 没有无参构造，报错！
Son(String name) {
super(name); // ✅ 必须显式调用
}
}
口诀：父类有参子类忧，super 显式写开头。
5.3 重写（Override）vs 重载（Overload）
前面那道面试题里，选项把"重写"写成了"重载"，这是两个完全不同的概念。
| 对比项 | 重写 Override | 重载 Overload |
|
位置 |
父子类之间 |
同一个类中 |
|
方法名 |
必须相同 |
必须相同 |
|
参数列表 |
必须相同 |
必须不同 |
|
返回值 |
相同或子类型（协变） |
可以不同 |
|
访问权限 |
子类不能更严格 |
可以不同 |
|
异常 |
子类不能更宽泛 |
可以不同 |
|
多态性 |
运行时绑定 |
编译时绑定 |
class Father {
void show(String msg) {}
}
class Son extends Father {
@Override
void show(String msg) {} // 重写：参数完全相同
void show(int num) {} // 重载：参数不同（和父类无关，这是 Son 自己的重载）
}
六、面试高频题解析
题 1：抽象类能 final 吗？
不能。 abstract 要求子类继承，final 禁止继承，两者矛盾。
final abstract class Test {} // ❌ 编译报错
题 2：接口能继承类吗？
不能。 接口只能继承接口（而且是多继承）。
interface A {}
interface B {}
// 接口可以多继承接口
interface C extends A, B {}
// ❌ interface 不能 extends class
interface D extends TestClass {}
题 3：抽象类可以实现接口吗？
可以。 抽象类实现接口时，可以不实现接口的抽象方法，留给子类去实现。
interface Flyable {
void fly();
}
abstract class Bird implements Flyable {
// 不实现 fly()，没问题
}
class Sparrow extends Bird {
@Override
public void fly() {
System.out.println("麻雀飞");
}
}
题 4：接口里的方法默认是什么修饰符？
JDK 8 之前：隐式 public abstract
JDK 8+：抽象方法仍然是 public abstract；default 方法是 public；static 方法是 public
JDK 9+：可以有 private 方法
注意：如果你写接口方法时没加 public，编译器会自动加上，但实现类重写时必须写 public（因为子类不能缩小访问权限）。
题 5：一个类可以同时继承抽象类和实现接口吗？
可以。
abstract class Animal {}
interface Runnable {}
class Dog extends Animal implements Runnable {}
题 6：抽象类和接口的选择？
| 场景 | 选择 |
|
有共同代码需要复用 |
抽象类 |
|
只是定义行为规范，无关的类都要遵守 |
接口 |
|
需要多重继承效果 |
接口 |
|
框架设计，模块解耦 |
接口 |
|
模板方法模式 |
抽象类 |
七、设计模式中的应用
7.1 模板方法模式（抽象类经典应用）
abstract class DataImporter {
// 模板方法：定义算法骨架
final void importData() {
validate(); // 通用
parse(); // 子类实现
transform(); // 通用
save(); // 子类实现
log(); // 通用
}
void validate() {
System.out.println("验证数据格式");
}
abstract void parse();
abstract void save();
void transform() {
System.out.println("转换数据");
}
void log() {
System.out.println("记录导入日志");
}
}
class ExcelImporter extends DataImporter {
@Override
void parse() {
System.out.println("解析 Excel 文件");
}
@Override
void save() {
System.out.println("保存到数据库");
}
}
class CsvImporter extends DataImporter {
@Override
void parse() {
System.out.println("解析 CSV 文件");
}
@Override
void save() {
System.out.println("保存到数据库");
}
}
抽象类把通用逻辑（validate、transform、log）固化，把变化点（parse、save）留给子类。这是抽象类最经典的用法。
7.2 策略模式（接口经典应用）
interface PaymentStrategy {
void pay(double amount);
}
class AlipayStrategy implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println("支付宝支付 " + amount + " 元");
}
}
class WechatStrategy implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println("微信支付 " + amount + " 元");
}
}
class PaymentContext {
private PaymentStrategy strategy;
void setStrategy(PaymentStrategy strategy) {
this.strategy = strategy;
}
void executePay(double amount) {
strategy.pay(amount);
}
}
接口定义支付标准，不同支付方式各自实现，客户端可以动态切换策略。
八、JDK 8 之后的接口变化：面试必考
很多老教程还在说"接口只能有抽象方法"，这是过时的。现代 Java 面试必须知道：
8.1 default 方法冲突
一个类实现了两个接口，两个接口有同名同参的 default 方法，怎么办？
interface A {
default void hello() {
System.out.println("A");
}
}
interface B {
default void hello() {
System.out.println("B");
}
}
class C implements A, B {
// ❌ 编译报错：C 从 A 和 B 继承了重复的默认方法
// ✅ 必须显式重写，指定用哪个
@Override
public void hello() {
A.super.hello(); // 调用 A 的默认方法
// 或者自己写逻辑
}
}
8.2 接口与抽象类的"模糊地带"
JDK 8 之后，接口有了 default 方法，某种程度上也能提供默认实现，那和抽象类是不是越来越像了？
本质区别仍然在：
-
抽象类可以有成员变量、构造方法、各种访问权限
-
接口还是只能有常量和 public 方法
-
抽象类是单继承，接口是多实现
所以即使接口有了 default，它依然是"规范定义者"的角色，不是"代码复用者"的角色。
九、总结：一张图记住所有区别
┌─────────────────────────────────────────────────────────────┐
│ 抽象类 vs 接口 │
├─────────────────────────────────────────────────────────────┤
│ 抽象类 (abstract class) │
│ ├── 定位：半成品，is-a 关系 │
│ ├── 构造方法：✅ 有 │
│ ├── 成员变量：普通变量 + 常量 │
│ ├── 方法：完整方法 + 抽象方法 │
│ ├── 继承：单继承 │
│ └── 场景：代码复用、模板方法 │
├─────────────────────────────────────────────────────────────┤
│ 接口 (interface) │
│ ├── 定位：能力标签，can-do 关系 │
│ ├── 构造方法：❌ 没有 │
│ ├── 成员变量：只能 public static final 常量 │
│ ├── 方法：JDK8+ 抽象/default/static/private │
│ ├── 继承：多实现 │
│ └── 场景：定义标准、解耦、多态扩展 │
└─────────────────────────────────────────────────────────────┘
十、写在最后
抽象类和接口是 Java 面向对象设计的两大基石。理解它们的关键不在于背语法，而在于理解设计意图：
-
抽象类解决的是"代码复用 + 部分约束"的问题，它是纵向的继承体系，强调"你属于这个家族，所以你天然拥有家族的共性"。
-
接口解决的是"行为规范 + 解耦扩展"的问题，它是横向的能力组合，强调"你能做什么，我不关心你是什么"。
在实际开发中，两者经常配合使用：用抽象类提供默认实现减少重复代码，用接口定义扩展点保证架构灵活。
希望这篇文章能帮你彻底理清抽象类和接口的所有细节。
更多推荐
12
0- 0
已为社区贡献3条内容
所有评论(0)