核心定義對比
| 維度 | 抽象類 (abstract class) | 接口 (interface) |
| 關鍵字 | abstract class | interface |
| 方法實現 | 可有具體方法、抽象方法、構造方法 | Java 8 前:全抽象;Java 8+:default/static/private 方法可有實現 |
| 字段 | 實例變量、靜態變量、常量 | 僅常量 (public static final 隱式) |
| 構造器 | 有(子類調用 super()) | 無 |
| 訪問修飾符 | 任意 | 方法默認 public,字段默認 public static final |
| 繼承/實現 | 單繼承 (extends) | 多實現 (implements),接口間可多繼承 (extends) |
| 設計意圖 | 「是一種」關係,共享代碼/狀態 | 「能做什麼」契約,定義行為規範 |
代碼示例:抽象類
public abstract class Animal {
// 共享字段
protected String name;
protected int age;
// 構造器
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
// 具體方法(模板方法模式)
public final void dailyRoutine() {
wakeUp();
eat();
sleep();
}
// 抽象方法:強制子類實現
protected abstract void makeSound();
// 普通方法:可被重寫
protected void eat() {
System.out.println(name + " 正在吃飯...");
}
private void wakeUp() {
System.out.println(name + " 醒來了");
}
private void sleep() {
System.out.println(name + " 睡著了");
}
}
public class Dog extends Animal {
public Dog(String name, int age) {
super(name, age);
}
@Override
protected void makeSound() {
System.out.println(name + ":汪汪汪!");
}
}
代碼示例:接口 (Java 8+)
public interface Swimmable {
// 抽象方法(隱式 public abstract)
void swim();
// 默認方法:提供默認實現,不破壞舊實現類
default void dive() {
System.out.println("潛水中...");
}
// 靜態方法:工具方法,屬於接口而非實例
static boolean isWaterSafe(String waterType) {
return "pool".equals(waterType) || "lake".equals(waterType);
}
// 私有方法:供默認/靜態方法內部復用 (Java 9+)
private void log(String action) {
System.out.println("[Swimmable] " + action);
}
}
public interface Flyable {
void fly();
default void glide() { System.out.println("滑翔中..."); }
}
// 多實現
public class Duck extends Animal implements Swimmable, Flyable {
public Duck(String name, int age) {
super(name, age);
}
@Override
protected void makeSound() {
System.out.println(name + ":嘎嘎嘎!");
}
@Override
public void swim() {
System.out.println(name + " 游泳~");
}
@Override
public void fly() {
System.out.println(name + " 飛起來!");
}
}
選型決策樹
需要定義類型契約嗎?
├── 是 → 需要多實現/組合行為嗎?
│ ├── 是 → 用 interface
│ └── 否 → 需要共享代碼/狀態/構造器嗎?
│ ├── 是 → 用 abstract class
│ └── 否 → 用 interface (更輕量)
└── 否 → 只是工具類/工廠/單例 → 考慮 final class + 靜態方法
經典誤區與避坑指南
| 誤區 | 正確理解 |
| 「接口不能有方法實現」 | Java 8+ 支持 default/static/private 方法實現 |
| 「抽象類比接口強」 | 職責不同:抽象類為「垂直繼承共享」,接口為「橫向能力組合」 |
| 「一個類只能實現一個接口」 | 可 implements A, B, C 多實現 |
| 「接口字段可修改」 | 接口字段隱式 public static final,不可變 |
| 「抽象類不能實例化,接口也不能」 | 正確,但接口可通過匿名內部類/lambda 直接實例化實現 |
| 「抽象類構造器無用」 | 子類必須調用 super(),用於初始化共享字段 |
實戰場景對照
場景一:模板方法模式 → 抽象類
abstract class OrderProcessor {
// 固定流程
public final void process(Order order) {
validate(order);
pay(order);
ship(order);
notify(order);
}
protected abstract void pay(Order order); // 子類定制支付方式
// 其他步驟提供默認實現...
}
場景二:插件化能力擴展 → 接口
interface Plugin {
void init(Context ctx);
void execute();
void destroy();
}
// 主程序動態加載多個 Plugin 實現
List plugins = loadPlugins();
plugins.forEach(p -> p.init(ctx));
plugins.forEach(Plugin::execute);
場景三:領域模型基類 → 抽象類
abstract class Entity {
protected ID id;
protected LocalDateTime createdAt;
protected LocalDateTime updatedAt;
// 共享 equals/hashCode/toString 基於 id
}
場景四:函數式接口 → Lambda 友好
@FunctionalInterface
interface Converter {
R convert(T input);
}
// 使用
Converter toInt = Integer::parseInt;
Integer val = toInt.convert("123");
總結
抽象類與接口不是非此即彼的對立,而是**垂直復用**與**橫向契約**的互補:
- 需要**共享狀態、構造器、非公共方法** → 抽象類
- 需要**多實現、能力組合、框架擴展點、Lambda 適配** → 接口
- 現代 Java (8+) 中,接口獲得 default/private 方法後,邊界進一步模糊,**「優先用接口,必要時抽象類」** 成為主流原則