返回专栏
· 23 分钟阅读

面向对象编程(Object-Oriented Programming,OOP)


一、什么是面向对象编程?

面向对象编程(Object-Oriented Programming,简称 OOP)是一种以对象(Object)为核心组织程序的编程范式。

它将现实问题或业务领域中的实体抽象为对象,通过对象保存状态、提供行为,并通过对象之间的协作完成系统功能。

面向对象编程关注的问题包括:

  • 系统中有哪些对象?
  • 每个对象负责什么职责?
  • 对象内部应该保存哪些状态?
  • 对象对外提供哪些操作?
  • 不同对象之间如何协作?
  • 如何通过继承、组合和多态实现扩展?

例如,一个电商系统可以抽象出以下对象:

  • User:用户。
  • Product:商品。
  • Order:订单。
  • Payment:支付。
  • Inventory:库存。

每个对象负责管理自身相关的数据和行为,多个对象通过方法调用、接口或消息进行协作。

1. 核心思想

面向对象编程的核心思想是:

将数据与操作数据的行为组织在对象中,通过对象之间的协作构建完整程序。

一个典型的面向对象系统可以抽象为:

flowchart TD
    A["业务需求"] --> B["识别领域实体"]
    B --> C["抽象对象与职责"]
    C --> D["定义类与接口"]
    D --> E["创建对象实例"]
    E --> F["对象之间协作"]
    F --> G["完成业务功能"]

    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:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

面向对象编程并不是简单地将函数放进类中,而是通过合理的对象边界、职责划分和协作关系管理系统复杂度。


二、类与对象:面向对象的基础

类和对象是理解 OOP 的两个基本概念。

1. 类(Class)

类是对象的抽象定义,用于描述一类对象具有哪些属性和行为。

例如,定义一个用户类:

public class User {
    String name;
    int age;

    void login() {
        System.out.println("用户登录");
    }

    void logout() {
        System.out.println("用户退出");
    }
}

这里:

  • User:类名。
  • name、age:属性,用于描述对象状态。
  • login()、logout():方法,用于描述对象行为。

类定义了对象的结构和操作方式,但类本身不等于某个具体对象。

2. 对象(Object)

对象是类的具体实例。

User user1 = new User();
user1.name = "Alice";
user1.age = 25;

User user2 = new User();
user2.name = "Bob";
user2.age = 30;

user1 和 user2 都是 User 类的实例,但它们具有不同的状态。

对象通常包含两个重要方面:

  • 状态(State):对象当前保存的数据。
  • 行为(Behavior):对象能够执行的操作。
概念 说明 示例
类 对象的抽象定义 User
对象 类的具体实例 user1
属性 描述对象状态 name、age
方法 描述对象行为 login()
实例化 创建对象的过程 new User()

3. 类与对象的关系

可以将类理解为对象的类型定义,将对象理解为该类型的具体实例。

flowchart TD
    A["User 类"] --> B["对象实例 user1"]
    A --> C["对象实例 user2"]
    A --> D["对象实例 user3"]

    B --> E["name = Alice<br/>age = 25"]
    C --> F["name = Bob<br/>age = 30"]
    D --> G["name = Carol<br/>age = 28"]

    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

需要注意:

  • 类是类型或结构的定义,不代表所有语言都采用相同的内存实现。
  • 对象是运行时实体,但不一定全部通过传统的堆内存分配实现。
  • 某些语言支持原型对象、结构体或其他对象模型,并不一定使用传统的类机制。

三、面向对象的四大基本特征

面向对象编程通常通过四个核心概念进行介绍:

  1. 抽象(Abstraction)。
  2. 封装(Encapsulation)。
  3. 继承(Inheritance)。
  4. 多态(Polymorphism)。

这四个概念共同构成了经典 OOP 的理论基础,但它们并不是所有面向对象语言必须采用的唯一实现方式。

1. 抽象(Abstraction)

抽象是从复杂事物中提取关键特征,忽略与当前问题无关的细节。

例如,设计一个支付系统时,业务代码可能只关心:

  • 支付金额。
  • 支付方式。
  • 支付结果。
  • 支付状态。

至于底层如何连接支付渠道、如何加密请求、如何处理网络重试,可以隐藏在具体实现中。

抽象的目标是建立清晰的概念模型,降低系统理解成本。

代码示例:

interface Payment {
    void pay(double amount);
}

定义支付接口后,不同支付渠道可以实现相同的操作约定:

class Alipay implements Payment {
    public void pay(double amount) {
        System.out.println("支付宝支付:" + amount);
    }
}

class WeChatPay implements Payment {
    public void pay(double amount) {
        System.out.println("微信支付:" + amount);
    }
}

调用方只需要知道 Payment 接口,不需要了解具体支付渠道的内部实现。

抽象的价值:

  • 隐藏复杂实现细节。
  • 建立稳定的业务接口。
  • 降低调用方对具体实现的依赖。
  • 支持不同实现之间的替换。

2. 封装(Encapsulation)

封装是将数据和操作数据的方法组织在一起,并通过访问控制限制外部对内部状态的直接访问。

例如:

public class Account {
    private double balance;

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

        balance += amount;
    }

    public double getBalance() {
        return balance;
    }
}

这里:

  • balance 是私有属性。
  • 外部不能直接修改账户余额。
  • deposit() 提供受控的修改入口。
  • getBalance() 提供读取入口。

封装不仅仅是将属性设置为 private,更重要的是保护对象的不变量(Invariant)。

例如,账户余额不能因为任意外部赋值而违反业务规则。

封装的价值:

  • 控制数据访问。
  • 保护对象状态。
  • 保证业务约束。
  • 减少外部代码对内部实现的依赖。

3. 继承(Inheritance)

继承允许一个类基于另一个类定义,从而复用或扩展已有属性和行为。

例如:

class Animal {
    void eat() {
        System.out.println("动物进食");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("狗叫");
    }
}

Dog 继承 Animal,可以使用父类提供的 eat() 方法,同时增加自己的 bark() 方法。

继承关系通常可以表达为:

flowchart TD
    A["Animal 父类"] --> B["Dog 子类"]
    A --> C["Cat 子类"]
    B --> D["继承 eat()"]
    B --> E["扩展 bark()"]
    C --> F["继承 eat()"]
    C --> G["扩展 meow()"]

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

继承的主要作用:

  • 复用已有实现。
  • 表达类型之间的关系。
  • 扩展已有行为。
  • 支持运行时多态。

但继承也会带来耦合问题。

子类可能依赖父类的内部实现,父类的修改可能影响所有子类。因此,继承应该表达合理的类型关系,而不是单纯为了减少重复代码。

4. 多态(Polymorphism)

多态是指相同的接口或操作,在不同对象上可以表现出不同的行为。

例如:

interface Animal {
    void speak();
}

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

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

调用方:

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        animal1.speak();
        animal2.speak();
    }
}

虽然两个变量的声明类型都是 Animal,但实际调用的实现不同。

flowchart TD
    A["Animal 接口"] --> B["Dog 对象"]
    A --> C["Cat 对象"]
    D["调用 speak()"] --> E["根据实际对象选择实现"]
    B --> E
    C --> E
    E --> F["Dog.speak()"]
    E --> G["Cat.speak()"]

    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:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

多态的核心价值:

  • 调用方依赖抽象接口。
  • 不同实现可以独立扩展。
  • 减少业务代码中的条件判断。
  • 提高系统的可扩展性。

需要区分:多态不只存在于继承体系中。接口实现、函数重载、泛型和鸭子类型等机制,也可以在不同层面体现多态思想。


四、对象的内部结构与运行机制

理解 OOP 不能只关注类的语法,还需要了解对象在运行时如何表示、创建、访问和销毁。

1. 对象的状态与行为

对象通常由状态和行为两个维度描述。

状态:

对象内部保存的数据。

例如:

class User {
    String name;
    int age;
    boolean active;
}

行为:

对象能够执行的操作。

class User {
    String name;
    int age;

    void login() {
        System.out.println(name + " 登录");
    }

    void updateAge(int age) {
        this.age = age;
    }
}

状态描述对象当前是什么样子,行为描述对象能够做什么。

2. 对象引用与对象实例

在 Java 中:

User user = new User();

这里需要区分:

  • User:引用变量的声明类型。
  • user:局部引用变量。
  • new User():创建对象实例的表达式。
  • =:将对象引用赋值给变量。

概念上可以表示为:

flowchart LR
    A["引用变量 user"] --> B["User 对象"]
    B --> C["name"]
    B --> D["age"]
    B --> E["login()"]

    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

这里的示意图表达的是引用与对象的逻辑关系,不代表所有语言都采用相同的内存布局。

在 Java 中,引用变量保存对象引用;在 C++ 中,对象可以直接存储在自动存储期对象中,也可以通过指针或智能指针间接访问。

3. 对象在内存中的布局

在传统运行时实现中,对象可能包含:

  • 实例字段。
  • 对齐填充。
  • 对象头。
  • 类型或运行时元数据。
  • 垃圾回收相关信息。

以典型 Java 虚拟机实现为例,对象通常包含对象头和实例数据,具体布局取决于 JVM 实现、压缩指针、对象对齐等因素。

需要注意:

  • 类的方法通常不需要为每个实例复制一份机器代码。
  • 多个对象可以共享同一个类的方法实现。
  • 实例字段通常属于各自对象。
  • 静态字段属于类或对应的运行时类型状态,而不是每个对象单独保存。

不能将某一种虚拟机的对象布局当作所有面向对象语言的统一规范。

4. 构造函数与对象初始化

构造函数(Constructor)通常用于建立对象初始状态。

例如:

class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

创建对象:

User user = new User("Alice", 25);

构造过程可以抽象为:

flowchart TD
    A["请求创建对象"] --> B["分配或准备对象存储"]
    B --> C["初始化默认状态"]
    C --> D["执行构造逻辑"]
    D --> E{"初始化是否成功"}
    E -->|"是"| F["获得可用对象"]
    E -->|"否"| G["报告初始化失败"]

    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:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#FBE9E9,stroke:#D9AAAA,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这是简化的概念流程。不同语言对内存准备、字段初始化、基类构造和构造失败的处理有不同规定。

例如:

  • Java 使用构造方法初始化对象。
  • C++ 通过构造函数和成员初始化列表建立对象状态。
  • Python 通常通过 __new__() 创建实例,再通过 __init__() 初始化实例。
  • Rust 通过结构体表达式和关联函数构造值,并没有传统意义上的类构造函数。

5. 对象生命周期

对象生命周期描述对象从创建到不再有效的过程。

不同语言采用不同的资源管理方式:

语言 常见生命周期管理机制
Java 垃圾回收
C# 垃圾回收
Python 引用计数与循环垃圾回收等实现机制
C++ 自动存储期、析构函数、RAII、智能指针
Rust 所有权、借用与生命周期规则
Go 垃圾回收

在 C++ 中:

class User {
public:
    User() {
        std::cout << "创建对象" << std::endl;
    }

    ~User() {
        std::cout << "销毁对象" << std::endl;
    }
};

int main() {
    User user;
    return 0;
}

局部对象通常在离开其生命周期范围时自动调用析构函数。

在 Java 中,对象的可达性和垃圾回收决定对象何时能够被回收,但垃圾回收时间并不保证与对象离开作用域的时刻一致。


五、继承机制与类型体系

继承是面向对象语言组织类型关系的重要机制。

1. 父类与子类

父类定义通用属性和行为,子类继承并扩展这些能力。

class Vehicle {
    String brand;

    void start() {
        System.out.println("车辆启动");
    }
}

class Car extends Vehicle {
    int doors;

    void drive() {
        System.out.println("汽车行驶");
    }
}

Car 可以使用从 Vehicle 继承的 brand 和 start(),也可以定义自己的 doors 和 drive()。

2. 方法重写(Method Overriding)

子类可以重新实现父类已经定义的方法。

class Animal {
    void speak() {
        System.out.println("动物发声");
    }
}

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

调用:

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

如果该方法参与动态分派,将执行 Dog 的实现。

方法重写是运行时多态的重要基础。

3. 单继承与多继承

不同语言对继承体系的支持不同。

语言 类继承特征
Java 类采用单继承,接口支持多实现
C# 类采用单继承,接口支持多实现
C++ 支持多继承
Python 支持多继承
Go 不提供传统类继承,主要通过组合与接口实现抽象
Rust 不提供传统类继承,主要通过组合和 Trait 实现抽象

多继承可以表达更复杂的类型关系,但也会带来:

  • 菱形继承问题。
  • 方法解析顺序复杂。
  • 父类状态重复。
  • 类型关系难以理解。
  • 维护成本增加。

C++ 通过虚继承等机制处理部分菱形继承问题,Python 则通过 MRO(Method Resolution Order)确定方法查找顺序。

4. 继承与组合

继承表达的是一种类型上的关系,通常适合表示“是一种”(is-a)。

组合表达的是对象之间的包含或协作关系,通常适合表示“拥有一个”(has-a)。

例如:

class Engine {
    void start() {
        System.out.println("发动机启动");
    }
}

class Car {
    private Engine engine = new Engine();

    void start() {
        engine.start();
    }
}

这里 Car 通过组合拥有 Engine,而不是继承 Engine。

在复杂系统中,组合通常比深层继承更加灵活。


六、多态与动态绑定

多态是 OOP 中非常重要的机制,也是理解面向对象运行时行为的关键。

1. 静态类型与动态类型

以 Java 为例:

Animal animal = new Dog();

这里存在两个不同概念:

  • 静态类型(Static Type):变量声明时的类型,即 Animal。
  • 动态类型(Dynamic Type):运行时对象的实际类型,即 Dog。

静态类型主要影响编译阶段的类型检查和成员访问是否合法。

动态类型则会参与某些运行时方法分派。

2. 动态绑定(Dynamic Binding)

动态绑定是指方法调用的具体实现,在运行时根据对象实际类型确定。

例如:

class Animal {
    void speak() {
        System.out.println("动物发声");
    }
}

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

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

调用:

Animal[] animals = {
    new Dog(),
    new Cat()
};

for (Animal animal : animals) {
    animal.speak();
}

运行时调用过程:

flowchart TD
    A["调用 animal.speak()"] --> B["读取对象实际类型"]
    B --> C{"实际类型"}
    C -->|"Dog"| D["执行 Dog.speak()"]
    C -->|"Cat"| E["执行 Cat.speak()"]
    D --> F["返回调用方"]
    E --> F

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

这里需要区分:

  • 方法重写是语言层面的行为定义。
  • 动态绑定是运行时选择具体实现的机制。
  • 虚方法表(VTable)是部分编译型语言常见的实现方式,并不是多态必须采用的唯一机制。

3. 虚函数与虚方法表

在 C++ 中,使用 virtual 可以声明虚函数。

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

    virtual ~Animal() = default;
};

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

调用:

Animal* animal = new Dog();
animal->speak();

delete animal;

由于 speak() 是虚函数,调用时会根据对象的动态类型进行动态分派。

在常见 C++ ABI 实现中,编译器通常使用虚函数表(Virtual Table,VTable)支持动态分派。

概念上可以理解为:

  • 对象关联相应的动态类型信息。
  • 类型对应一组虚函数入口。
  • 虚函数调用根据动态类型找到实际实现。

但需要注意:

  • C++ 标准并未强制规定必须使用 VTable。
  • VTable 的具体布局由 ABI 和编译器实现决定。
  • 并非所有成员函数都通过虚函数表调用。
  • 编译器可能通过去虚拟化(Devirtualization)优化,将动态调用转换为直接调用。

七、接口与抽象类

接口和抽象类都是建立抽象边界的重要工具,但它们的语义并不相同。

1. 接口(Interface)

接口定义一组行为约定,具体实现由实现接口的类型提供。

interface Storage {
    void save(String data);
    String read();
}

不同存储方式可以实现相同接口:

class FileStorage implements Storage {
    public void save(String data) {
        System.out.println("保存到文件");
    }

    public String read() {
        return "文件数据";
    }
}

class DatabaseStorage implements Storage {
    public void save(String data) {
        System.out.println("保存到数据库");
    }

    public String read() {
        return "数据库数据";
    }
}

调用方只需要依赖 Storage:

void process(Storage storage) {
    storage.save("hello");
}

这使业务逻辑不必直接依赖文件存储或数据库存储的具体实现。

2. 抽象类(Abstract Class)

抽象类是一种不能直接实例化的类,通常用于定义共同状态和部分行为。

abstract class Animal {
    protected String name;

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

    abstract void speak();

    void sleep() {
        System.out.println(name + " 正在睡觉");
    }
}

子类必须根据语言规则实现相关抽象方法,才能成为可实例化的具体类型。

3. 接口与抽象类对比

对比维度 接口 抽象类
核心作用 定义行为契约 提供共同抽象与部分实现
实例化 通常不能直接实例化 不能直接实例化
状态 通常不承担普通实例状态存储 可以包含实例字段
方法实现 取决于语言,可能允许默认实现 可以包含具体方法
继承关系 一个类型可以实现多个接口 Java 类只能继承一个类
主要用途 解耦实现、统一调用约定 共享状态和通用实现

接口与抽象类的具体能力会随语言而变化。例如 Java 接口支持默认方法,C++ 则通常通过包含纯虚函数的抽象类表达类似接口的概念。


八、对象之间的关系

面向对象系统不仅包含单个对象,还包含对象之间的关系。

1. 关联(Association)

关联表示两个对象之间存在某种业务联系。

例如: