一、面向对象的三大核心特征
面向对象编程(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 什么是封装
封装是将数据与操作数据的行为组织在同一个对象或模块中,并通过受控接口向外部提供访问能力。
封装的核心目标不是简单地隐藏变量,而是:
- 隐藏内部实现细节。
- 限制外部对内部状态的直接修改。
- 通过公开接口维护数据一致性。
- 降低模块之间的耦合。
- 允许内部实现变化而尽量不影响外部调用者。
例如,一个银行账户包含余额、账户持有人和存取款操作。
如果余额可以被任意修改,就很难保证账户状态的合法性。
不推荐的设计:
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)。
不变量是对象在整个有效生命周期中必须满足的条件。
例如账户余额不能为负数:
每次修改余额时,都必须满足这一约束。
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
继承主要体现两个方面:
- 子类可以复用父类中允许继承的成员。
- 子类可以扩展自己的属性和方法,或重新定义继承的方法。
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。
此时可能出现:
Base的成员查找存在歧义。Base的初始化逻辑可能被执行多次。- 不同父类之间可能出现方法名称冲突。
- 对象内部可能存在多个基类子对象。
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。
虚函数调用过程可以抽象为: