返回专栏
· 21 分钟阅读

封装、继承与多态


一、面向对象的三大核心特征

面向对象编程(Object-Oriented Programming,OOP)通过对象组织数据和行为。其中,封装、继承与多态是最具代表性的三个核心特征。

核心特征 英文名称 主要解决的问题
封装 Encapsulation 如何保护对象内部状态,控制外部访问
继承 Inheritance 如何复用已有类型的属性和行为
多态 Polymorphism 如何通过统一接口实现不同的行为

三者之间存在一定联系,但解决的问题不同:

  • 封装关注对象内部实现与外部接口之间的边界。
  • 继承关注类型之间的关系与代码复用。
  • 多态关注同一接口在不同对象上的行为差异。
flowchart TB
    A["面向对象编程 OOP"]
    B["封装 Encapsulation"]
    C["继承 Inheritance"]
    D["多态 Polymorphism"]

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

    B --> E["保护内部状态<br/>控制访问边界"]
    C --> F["建立类型关系<br/>复用已有实现"]
    D --> G["统一接口<br/>动态分派行为"]

    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
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

二、封装(Encapsulation)

2.1 什么是封装

封装是将数据与操作数据的行为组织在同一个对象或模块中,并通过受控接口向外部提供访问能力。

封装的核心目标不是简单地隐藏变量,而是:

  1. 隐藏内部实现细节。
  2. 限制外部对内部状态的直接修改。
  3. 通过公开接口维护数据一致性。
  4. 降低模块之间的耦合。
  5. 允许内部实现变化而尽量不影响外部调用者。

例如,一个银行账户包含余额、账户持有人和存取款操作。

如果余额可以被任意修改,就很难保证账户状态的合法性。

不推荐的设计:

class Account:
    def __init__(self, balance):
        self.balance = balance


account = Account(1000)

account.balance = -5000

外部代码可以直接将余额修改为负数,绕过业务规则。

采用封装:

class Account:
    def __init__(self, balance):
        if balance < 0:
            raise ValueError("初始余额不能为负数")

        self.__balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("存款金额必须大于零")

        self.__balance += amount

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("取款金额必须大于零")

        if amount > self.__balance:
            raise ValueError("余额不足")

        self.__balance -= amount

    def get_balance(self):
        return self.__balance

调用:

account = Account(1000)

account.deposit(500)
account.withdraw(200)

print(account.get_balance())  # 1300

外部代码通过 deposit() 和 withdraw() 修改余额,账户对象负责维护自身状态。

2.2 访问控制

访问控制用于规定类成员可以被哪些代码访问。

Java、C++ 等语言通常提供明确的访问修饰符。

修饰符 访问范围 说明
public 公开访问 允许外部访问
protected 受保护访问 通常允许子类及特定范围访问
private 私有访问 限制在类内部访问
默认访问级别 依语言而定 例如 Java 的包级访问

Java 示例:

public class Account {
    private double balance;

    public Account(double balance) {
        if (balance < 0) {
            throw new IllegalArgumentException("余额不能为负数");
        }

        this.balance = balance;
    }

    public void deposit(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("金额必须大于零");
        }

        balance += amount;
    }

    public double getBalance() {
        return balance;
    }
}

其中:

  • balance 是私有字段。
  • deposit() 是公开操作接口。
  • getBalance() 提供受控的数据读取能力。

需要注意,protected 的具体访问规则具有语言差异。例如 Java 的 protected 还涉及包访问规则,不能简单等同于所有语言中的子类可访问。

2.3 不同语言的封装机制

封装是一种设计思想,不同语言提供的实现机制并不相同。

语言 常见实现方式
Java private、protected、public
C++ private、protected、public
Python 命名约定、名称改写、属性访问器
JavaScript #private 私有字段、闭包
Go 标识符首字母大小写控制导出
Rust 模块可见性、pub

例如 Python:

class User:
    def __init__(self, name):
        self._name = name
        self.__password = "secret"

    @property
    def name(self):
        return self._name

这里:

  • _name 表示约定上的非公开属性。
  • __password 会触发名称改写机制。
  • @property 允许通过属性访问语法调用方法。

Python 的双下划线并不等同于 Java 的严格 private。它主要通过名称改写降低意外访问和子类命名冲突的风险。

2.4 封装与数据完整性

封装的价值不仅是隐藏字段,更重要的是让对象负责维护自身的不变量(Invariant)。

不变量是对象在整个有效生命周期中必须满足的条件。

例如账户余额不能为负数:

balance \geq 0

每次修改余额时,都必须满足这一约束。

flowchart TB
    A["外部业务代码"]
    B["调用公开方法"]
    C["检查输入参数"]
    D{"是否满足业务约束"}
    E["拒绝操作"]
    F["修改内部状态"]
    G["保持对象不变量"]

    A --> B
    B --> C
    C --> D
    D -->|"否"| E
    D -->|"是"| F
    F --> G

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

实际开发中,封装通常与以下设计原则结合:

  • 将状态修改集中到明确的操作接口。
  • 在接口入口验证参数。
  • 避免暴露可被任意修改的内部集合。
  • 对并发访问的共享状态增加同步保护。
  • 让对象始终处于合法状态,避免部分初始化或非法状态传播。

2.5 封装不等于完全隐藏

封装并不意味着所有字段都必须私有,也不意味着不能公开对象属性。

例如,一个只读配置对象可以公开不可变属性,而无需为每个字段编写 getter 和 setter。

真正重要的是:外部能够进行哪些操作,这些操作是否会破坏对象约束。

盲目增加 getter 和 setter,可能只是把字段访问包装了一层,并没有真正实现有效封装。

三、继承(Inheritance)

3.1 什么是继承

继承是一种建立类型层次关系的机制,允许一个类型基于另一个类型扩展属性和行为。

被继承的类称为:

  • 父类(Parent Class)
  • 基类(Base Class)
  • 超类(Superclass)

继承其他类的类型称为:

  • 子类(Child Class)
  • 派生类(Derived Class)
  • 子类型(Subtype,具体含义需结合类型系统)

例如,系统中存在一个通用的 Animal 类,可以进一步定义 Dog 和 Cat。

class Animal:
    def eat(self):
        print("动物正在进食")


class Dog(Animal):
    def bark(self):
        print("汪汪")


class Cat(Animal):
    def meow(self):
        print("喵喵")


dog = Dog()
dog.eat()
dog.bark()

cat = Cat()
cat.eat()
cat.meow()

Dog 和 Cat 继承了 Animal 的 eat() 方法,同时拥有各自的行为。

3.2 继承的基本结构

flowchart TB
    A["Animal<br/>父类"]
    B["Dog<br/>子类"]
    C["Cat<br/>子类"]
    D["Bird<br/>子类"]

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

    B --> E["bark()"]
    C --> F["meow()"]
    D --> G["fly()"]

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

继承主要体现两个方面:

  1. 子类可以复用父类中允许继承的成员。
  2. 子类可以扩展自己的属性和方法,或重新定义继承的方法。

3.3 方法重写(Method Overriding)

方法重写是子类重新提供父类已有方法的实现。

class Animal:
    def speak(self):
        print("动物发出声音")


class Dog(Animal):
    def speak(self):
        print("汪汪")


class Cat(Animal):
    def speak(self):
        print("喵喵")

此时:

dog = Dog()
cat = Cat()

dog.speak()  # 汪汪
cat.speak()  # 喵喵

子类重写父类方法后,调用该方法时会根据实际对象类型选择对应实现。

这也是运行时多态的重要基础。

需要注意,方法重写与方法重载(Overloading)不是同一个概念:

对比 方法重写 方法重载
英文 Overriding Overloading
主要目的 改变继承方法的实现 提供不同参数形式的调用
是否依赖继承 通常依赖继承或接口实现关系 不一定
典型表现 子类重新实现父类方法 同名方法具有不同参数列表
常见语言 Java、C++、Python Java、C++

Python 不支持传统意义上基于多个参数签名的编译期方法重载,但可以通过默认参数、可变参数和分派机制实现类似效果。

3.4 super:调用父类实现

子类有时需要在扩展自身逻辑之前或之后调用父类方法。

Python 示例:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("动物发出声音")


class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

    def speak(self):
        super().speak()
        print("汪汪")

super() 用于按照方法解析顺序访问下一个实现。

在简单单继承中,它通常表现为调用父类实现;在 Python 多重继承中,它遵循 MRO(Method Resolution Order,方法解析顺序),并不只是简单地指向某一个固定父类。

3.5 继承的类型

根据继承关系的组织形式,常见继承类型包括:

类型 说明
单继承 一个子类继承一个直接父类
多重继承 一个子类继承多个父类
多层继承 继承关系形成多层层次
层次继承 多个子类继承同一个父类
混合继承 多种继承形式组合

示意:

flowchart TB
    A["Base"]
    B["ChildA"]
    C["ChildB"]
    D["ChildC"]
    E["GrandChild"]

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

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

不同语言对多重继承的支持不同:

  • C++ 支持类的多重继承。
  • Python 支持多重继承,并使用 MRO 解决方法查找顺序问题。
  • Java 的类只支持单继承,但可以实现多个接口。
  • C# 的类只支持单继承,但支持实现多个接口。
  • Go 不采用传统类继承机制,主要通过组合和接口实现代码复用与行为抽象。
  • Rust 不支持传统类继承,通过组合、trait 和泛型实现类似的抽象能力。

3.6 多重继承与菱形继承问题

多重继承可能导致复杂的成员查找和初始化问题。

典型场景是菱形继承:

flowchart TB
    A["Base"]
    B["Left"]
    C["Right"]
    D["Child"]

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

    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
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

假设:

  • Left 继承 Base。
  • Right 继承 Base。
  • Child 同时继承 Left 和 Right。

此时可能出现:

  1. Base 的成员查找存在歧义。
  2. Base 的初始化逻辑可能被执行多次。
  3. 不同父类之间可能出现方法名称冲突。
  4. 对象内部可能存在多个基类子对象。

C++ 通过虚继承(Virtual Inheritance)可以解决特定菱形继承场景中的共享基类子对象问题。

Python 则通过 MRO 确定方法查找顺序,并结合协作式 super() 调用实现复杂继承结构中的初始化协作。

Python 示例:

class A:
    def show(self):
        print("A")


class B(A):
    def show(self):
        print("B")
        super().show()


class C(A):
    def show(self):
        print("C")
        super().show()


class D(B, C):
    def show(self):
        print("D")
        super().show()


obj = D()
obj.show()

print(D.mro())

输出顺序:

D
B
C
A

这里的调用顺序由 D 的方法解析顺序决定。

3.7 继承的优点与问题

优点:

  • 复用已有代码。
  • 建立明确的类型层次。
  • 支持方法重写与多态。
  • 统一管理公共行为。
  • 便于表达稳定的领域类型关系。

问题:

  • 父类修改可能影响多个子类。
  • 继承层次过深会增加理解成本。
  • 子类容易依赖父类的内部实现。
  • 多重继承可能带来方法冲突和初始化复杂性。
  • 不恰当的继承会破坏类型替换关系。

继承不应仅仅为了复用几行代码而使用。只有当子类确实符合父类所表达的类型语义时,继承才是合理的设计。

四、多态(Polymorphism)

4.1 什么是多态

多态(Polymorphism)是指不同类型的对象可以通过统一的接口进行操作,并根据实际对象类型表现出不同的行为。

例如,系统定义一个统一的 speak() 方法:

  • Dog 调用 speak(),发出汪汪声。
  • Cat 调用 speak(),发出喵喵声。
  • Bird 调用 speak(),发出鸟鸣声。

调用者不需要了解每一种动物的内部实现,只需要按照统一接口调用即可。

class Animal:
    def speak(self):
        raise NotImplementedError


class Dog(Animal):
    def speak(self):
        print("汪汪")


class Cat(Animal):
    def speak(self):
        print("喵喵")


class Bird(Animal):
    def speak(self):
        print("啾啾")


def make_sound(animal):
    animal.speak()


animals = [
    Dog(),
    Cat(),
    Bird()
]

for animal in animals:
    make_sound(animal)

输出:

汪汪
喵喵
啾啾

make_sound() 不需要针对 Dog、Cat、Bird 分别编写调用逻辑。

4.2 多态的核心机制

多态的关键在于:

  • 统一的调用接口。
  • 不同类型的具体实现。
  • 根据类型系统和分派规则选择实际执行的方法。
flowchart TB
    A["调用者"]
    B["统一接口 speak()"]
    C{"实际对象类型"}
    D["Dog.speak()"]
    E["Cat.speak()"]
    F["Bird.speak()"]
    G["执行对应行为"]

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

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

需要注意:这里的类型判断是概念抽象。实际语言可能通过虚函数表、接口分派、方法查找、泛型单态化或其他机制实现多态。

4.3 编译时多态与运行时多态

多态可以按照方法或操作的分派时机进行分类。

类型 英文 主要特点
编译时多态 Compile-time Polymorphism 在编译阶段确定具体调用或实例化形式
运行时多态 Runtime Polymorphism 根据运行时对象类型确定具体行为

编译时多态

编译时多态通常包括:

  • 函数重载。
  • 运算符重载。
  • 模板与泛型的静态分派。
  • 编译器能够在编译阶段确定的具体实现。

C++ 函数重载示例:

#include <iostream>
#include <string>

void print(int value) {
    std::cout << value << std::endl;
}

void print(const std::string& value) {
    std::cout << value << std::endl;
}

int main() {
    print(100);
    print(std::string("Hello"));
}

编译器根据参数类型选择对应的函数版本。

C++ 模板示例:

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    int result1 = add(1, 2);
    double result2 = add(1.5, 2.5);
}

编译器根据模板参数生成相应的实例化代码。

运行时多态

运行时多态通常通过继承、接口和动态分派实现。

Java 示例:

abstract class Animal {
    public abstract void speak();
}

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

class Cat extends Animal {
    @Override
    public void speak() {
        System.out.println("喵喵");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.speak();

        animal = new Cat();
        animal.speak();
    }
}

虽然变量 animal 的声明类型始终是 Animal,但实际执行的方法取决于它引用的对象类型。

4.4 动态绑定(Dynamic Binding)

动态绑定是运行时多态的重要实现机制。

在支持动态分派的语言中,方法调用的具体实现可能无法仅根据变量声明类型确定,而需要根据运行时对象类型选择。

例如:

Animal animal = new Dog();
animal.speak();

这里:

  • Animal 是变量的声明类型。
  • Dog 是运行时对象的实际类型。
  • speak() 的具体实现由动态分派机制选择。

在 C++ 中,只有符合虚函数动态分派规则的调用才具有这种行为。

#include <iostream>

class Animal {
public:
    virtual void speak() {
        std::cout << "Animal" << std::endl;
    }

    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Dog" << std::endl;
    }
};

int main() {
    Animal* animal = new Dog();

    animal->speak();

    delete animal;
}

输出:

Dog

如果父类的 speak() 没有声明为 virtual,通过 Animal* 调用时就不会发生上述虚函数动态分派。

4.5 虚函数表(VTable)

在许多 C++ 编译器实现中,虚函数动态分派通常借助虚函数表(Virtual Table,VTable)实现。

需要强调:C++ 标准规定的是虚函数的语言行为,并不强制编译器必须使用 VTable。VTable 是主流实现技术。

其概念结构可以理解为:

Animal 类型
    speak() -> Animal::speak

Dog 类型
    speak() -> Dog::speak

Cat 类型
    speak() -> Cat::speak

对于具有虚函数的对象,典型实现会在对象中保存一个指向虚函数表的指针,常称为 vptr。

虚函数调用过程可以抽象为: