返回专栏
· 16 分钟阅读

抽象类与接口


一、什么是抽象类与接口

在面向对象编程中,抽象类和接口都是重要的抽象机制。

它们的共同目标是:定义一组规范,让不同的具体类型按照统一约定提供行为。

但二者的设计目的并不完全相同。

  • 抽象类(Abstract Class):用于定义一类对象的共同基础,可以包含属性、构造方法、普通方法和抽象方法。
  • 接口(Interface):用于定义类型需要遵守的行为契约,描述一个类型应该具备哪些能力。

例如,一个支付系统可能包含支付宝、微信支付和银行卡支付。

这些支付方式都需要实现支付行为,但具体支付逻辑各不相同。

可以通过抽象类或接口定义统一的支付规范,再由具体类型提供实现。

flowchart TB
    A["支付系统"]
    B["抽象定义"]
    C["具体支付实现"]
    D["支付宝"]
    E["微信支付"]
    F["银行卡支付"]

    A --> B
    B --> C
    C --> D
    C --> E
    C --> F

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

二、抽象类(Abstract Class)

2.1 抽象类的定义

抽象类是一种不能直接实例化的类,通常用于作为其他类的公共基类。

抽象类可以包含:

成员类型 是否允许 说明
普通属性 通常允许 保存对象或类型的状态
普通方法 允许 提供可复用的公共实现
抽象方法 允许 声明必须由具体子类实现的行为
构造方法 允许 初始化基类状态
静态成员 依语言而定 提供类级别的数据或行为
常量 依语言而定 定义固定值

抽象类可以同时承担两种职责:

  1. 定义子类必须遵守的行为规范。
  2. 为子类提供公共状态和可复用实现。

2.2 抽象方法

抽象方法只声明行为要求,不提供完整的具体实现,要求具体子类按照约定实现。

Java 示例:

abstract class Animal {

    public abstract void speak();

    public void sleep() {
        System.out.println("Animal is sleeping");
    }
}

其中:

  • speak() 是抽象方法。
  • sleep() 是普通方法。
  • Animal 是抽象类,不能直接通过 new Animal() 创建实例。

具体子类:

class Dog extends Animal {

    @Override
    public void speak() {
        System.out.println("汪汪");
    }
}

创建对象:

Animal animal = new Dog();

animal.speak();
animal.sleep();

Dog 实现了抽象方法,同时继承了 sleep() 的公共实现。

需要注意:不同语言对抽象方法的定义和实现要求存在差异。例如 Python 使用 abc 模块提供抽象基类机制,而 C++ 使用纯虚函数表达抽象行为。

2.3 抽象类不能直接实例化

抽象类本身通常是不完整的类型定义。

例如:

abstract class Shape {
    abstract double area();
}

下面的代码无法通过编译:

Shape shape = new Shape();

原因是 Shape 只声明了面积计算行为,并没有提供完整实现。

可以通过具体子类完成:

class Circle extends Shape {

    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

调用:

Shape shape = new Circle(5);

System.out.println(shape.area());

这里变量声明类型是 Shape,实际对象类型是 Circle。

这也是抽象类支持运行时多态的重要方式。

2.4 抽象类的主要用途

抽象类适合以下场景:

  • 多个子类具有相同的基础状态。
  • 多个子类需要共享公共实现。
  • 子类必须实现某些特定行为。
  • 希望通过基类统一管理初始化和公共流程。
  • 需要建立明确的父子类型关系。

例如,一个基础文件处理器可以提供公共的读取、关闭和异常处理逻辑,同时要求不同文件类型实现具体解析方法。

三、接口(Interface)

3.1 接口的定义

接口是一种用于定义行为契约的类型抽象。

它通常描述一个类型应该具备哪些操作,而不要求这些类型具有相同的内部数据结构或实现方式。

例如:

  • Runnable:表示可以执行任务。
  • Comparable:表示可以进行比较。
  • Serializable:表示支持序列化。
  • Payment:表示具备支付能力。

接口强调的是能力,而不是对象属于哪个具体类别。

3.2 接口的基本结构

Java 示例:

interface Payment {

    void pay(double amount);

    void refund(double amount);
}

该接口定义了两个行为:

  • 支付。
  • 退款。

具体实现类需要提供对应实现:

class Alipay implements Payment {

    @Override
    public void pay(double amount) {
        System.out.println("支付宝支付:" + amount);
    }

    @Override
    public void refund(double amount) {
        System.out.println("支付宝退款:" + amount);
    }
}

另一个实现:

class WechatPay implements Payment {

    @Override
    public void pay(double amount) {
        System.out.println("微信支付:" + amount);
    }

    @Override
    public void refund(double amount) {
        System.out.println("微信退款:" + amount);
    }
}

两个类没有必要继承同一个具体支付父类,也可以通过实现同一个接口提供统一能力。

3.3 一个类可以实现多个接口

这是接口相对于传统单继承类体系的重要特点。

Java 示例:

interface Runnable {
    void run();
}

interface Swimmable {
    void swim();
}

class Robot implements Runnable, Swimmable {

    @Override
    public void run() {
        System.out.println("机器人正在移动");
    }

    @Override
    public void swim() {
        System.out.println("机器人正在游泳");
    }
}

Robot 同时具备运行和游泳两种能力。

这种方式可以将不同能力拆分成独立接口,再根据具体类型的需求进行组合。

flowchart TB
    A["Robot"]
    B["Runnable 接口"]
    C["Swimmable 接口"]
    D["run()"]
    E["swim()"]

    A --> B
    A --> C
    B --> D
    C --> E

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

3.4 接口不仅可以包含抽象方法

早期 Java 接口主要用于定义抽象方法和常量。

从 Java 8 开始,接口还支持:

  • 默认方法(Default Method)。
  • 静态方法(Static Method)。

Java 9 又增加了私有方法支持。

例如:

interface Payment {

    void pay(double amount);

    default void validate(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("支付金额必须大于零");
        }
    }

    static boolean isValidAmount(double amount) {
        return amount > 0;
    }

    private void log(String message) {
        System.out.println(message);
    }
}

不同类型的接口成员具有不同语义:

成员 作用
抽象方法 定义实现类必须提供的行为
默认方法 为实现类提供可继承的默认实现
静态方法 提供属于接口本身的操作
私有方法 为接口内部方法复用提供支持
常量 定义接口级别的固定值

需要注意,Java 接口中的字段默认是 public static final,不能作为每个实现对象独立保存的实例字段。

3.5 接口与结构化类型

接口并不是所有语言实现抽象的唯一方式。

不同语言有不同的类型抽象机制:

  • Java、C# 使用显式接口实现。
  • Go 使用隐式接口实现。
  • TypeScript 使用结构化类型检查。
  • Rust 使用 trait 定义共享行为约束。
  • Python 可以通过抽象基类、协议(Protocol)等机制表达接口式约束。

例如 Go:

package main

import "fmt"

type Speaker interface {
    Speak()
}

type Dog struct{}

func (Dog) Speak() {
    fmt.Println("汪汪")
}

type Cat struct{}

func (Cat) Speak() {
    fmt.Println("喵喵")
}

func MakeSound(s Speaker) {
    s.Speak()
}

func main() {
    MakeSound(Dog{})
    MakeSound(Cat{})
}

Go 中 Dog 和 Cat 不需要显式声明实现了 Speaker。

只要类型的方法集合满足接口要求,就可以被视为实现了该接口。

这体现了 Go 的隐式接口机制。

四、抽象类与接口的核心区别

抽象类与接口都可以定义抽象行为,但它们的设计重点不同。

4.1 核心对比

对比维度 抽象类 接口
主要目的 定义共同基础与部分实现 定义行为契约
实例化 通常不能直接实例化 不能直接创建接口实例
普通属性 通常支持 取决于语言,Java 接口不支持实例字段
构造方法 通常支持 Java 接口不支持构造方法
普通方法 支持 依语言支持默认实现等
抽象方法 支持 通常支持
状态管理 可以保存实例状态 通常不负责实例状态管理
继承数量 Java、C# 等通常只能继承一个类 通常可以实现多个接口
关系表达 is-a has-a capability / can-do
典型用途 公共基础实现 跨类型能力抽象

需要特别注意:这张表主要以 Java 等具有传统抽象类与接口体系的语言为参照。不同语言的接口能力并不完全一致。

4.2 设计意图上的区别

抽象类通常表达:

这些类型属于同一类事物,并且具有共同的基础结构。

例如:

  • Dog 是一种 Animal。
  • Circle 是一种 Shape。
  • AdminUser 是一种 User。

接口通常表达:

这些类型都具备某种能力。

例如:

  • Printer 可以打印。
  • File 可以读取。
  • Payment 可以支付。
  • Comparable 可以比较。

同一个类可以属于一个基础类型,同时实现多个能力接口。

flowchart TB
    A["具体类型"]
    B["抽象类<br/>共同基础"]
    C["接口 A<br/>能力约束"]
    D["接口 B<br/>能力约束"]
    E["具体实现"]

    A --> B
    A --> C
    A --> D
    B --> E
    C --> E
    D --> E

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

五、抽象类与接口的底层实现机制

理解二者不能只停留在语法层面,还需要了解编译器和运行时如何处理这些抽象定义。

5.1 抽象类的实现机制

以 Java 为例,抽象类经过编译后会生成字节码。

抽象方法在字节码中具有抽象方法标记,不包含普通方法体对应的执行指令。

具体子类需要提供符合要求的实现。

运行时,JVM 根据对象的实际类型执行对应方法。

需要注意:

  • 抽象类本身仍然是一个类。
  • 抽象类可以拥有实例字段。
  • 抽象类可以拥有构造方法。
  • 抽象类可以提供已经实现的方法。
  • 抽象类不能直接实例化,但它的构造逻辑可以在子类创建过程中执行。

例如:

abstract class Animal {

    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public abstract void speak();
}

class Dog extends Animal {

    public Dog(String name) {
        super(name);
    }

    @Override
    public void speak() {
        System.out.println(name + " 汪汪");
    }
}

创建 Dog 对象时,父类构造逻辑会参与对象初始化过程。

5.2 接口的实现机制

以 Java 为例,接口也是 JVM 类型系统中的一种类型。

接口定义方法契约,实现类需要满足对应的实现要求。

接口调用可以通过 JVM 的接口方法分派机制完成。

字节码层面存在与接口调用相关的指令,例如 invokeinterface。

常见调用指令还包括:

指令 主要用途
invokevirtual 调用实例虚方法
invokeinterface 调用接口方法
invokestatic 调用静态方法
invokespecial 调用构造方法、私有方法或特定父类实现

这些是 JVM 字节码层面的机制,并不意味着所有语言的接口调用都使用相同方式。

5.3 抽象类与接口是否有运行时开销?

抽象类和接口本身是类型抽象机制,不应该简单认为它们一定会增加显著运行时开销。

真正需要关注的是具体实现和调用方式。

例如:

  • 虚方法调用可能涉及动态分派。
  • 接口调用可能需要接口方法查找。
  • JIT 编译器可能通过类型分析优化调用。
  • 当运行时类型可确定时,编译器可能执行去虚化。
  • 某些语言的泛型可能采用单态化,减少运行时分派。

在 Java 中,接口调用不一定比抽象类方法调用慢。实际性能取决于运行时类型分布、JIT 优化、调用频率和具体代码结构。

不应该为了避免接口调用开销而放弃合理的抽象设计。

六、抽象类与接口在主流语言中的实现

6.1 Java

Java 同时支持抽象类和接口。

abstract class Animal {
    public abstract void speak();

    public void eat() {
        System.out.println("Eating");
    }
}

interface Runnable {
    void run();
}

class Dog extends Animal implements Runnable {

    @Override
    public void speak() {
        System.out.println("汪汪");
    }

    @Override
    public void run() {
        System.out.println("Dog running");
    }
}

Java 的类型关系:

  • 一个类只能直接继承一个类。
  • 一个类可以实现多个接口。
  • 一个接口可以继承多个接口。
  • 抽象类可以实现接口,也可以继承其他抽象类。
  • 具体类必须实现其继承体系中尚未实现的抽象方法。

6.2 C++

C++ 没有单独的 interface 关键字。

通常通过只包含纯虚函数的抽象类模拟接口。

#include <iostream>

class Payment {
public:
    virtual void pay(double amount) = 0;

    virtual ~Payment() = default;
};

class Alipay : public Payment {
public:
    void pay(double amount) override {
        std::cout << "支付宝支付:" << amount << std::endl;
    }
};

int main() {
    Payment* payment = new Alipay();

    payment->pay(100);

    delete payment;
}

其中:

virtual void pay(double amount) = 0;

表示纯虚函数。

包含至少一个纯虚函数且未完成实现的类是抽象类,不能直接创建对象。

C++ 中的接口通常是一种设计约定,而不是独立的语言类型类别。

6.3 Python

Python 通过抽象基类(Abstract Base Class,ABC)实现类似抽象类和接口的约束。

from abc import ABC, abstractmethod


class Payment(ABC):

    @abstractmethod
    def pay(self, amount):
        pass

    def validate(self, amount):
        return amount > 0


class Alipay(Payment):

    def pay(self, amount):
        if not self.validate(amount):
            raise ValueError("金额必须大于零")

        print(f"支付宝支付:{amount}")

这里:

  • ABC 提供抽象基类机制。
  • @abstractmethod 声明抽象方法。
  • 子类必须实现所有尚未实现的抽象方法,才能正常实例化。
  • validate() 是可以复用的普通方法。

Python 还支持 Protocol,用于描述结构化接口。

from typing import Protocol


class Payment(Protocol):
    def pay(self, amount: float) -> None:
        ...


class Alipay:
    def pay(self, amount: float) -> None:
        print(f"支付宝支付:{amount}")


def process(payment: Payment):
    payment.pay(100)