返回专栏
· 13 分钟阅读

类与对象(Classes & Objects)


一、什么是类与对象

类与对象是面向对象编程(Object-Oriented Programming,OOP)的基础概念。

它们分别代表两个不同层次:

  • 类(Class):对一类事物共同特征和行为的抽象描述,定义对象应该具备哪些属性和方法。
  • 对象(Object):类的具体实例,拥有实际的数据,并能够执行类定义的行为。

例如,在一个用户管理系统中:

  • User 是一个类,用于描述用户具备哪些属性和行为。
  • 张三、李四是两个不同的用户对象,各自拥有独立的用户数据。

类描述共同结构,对象承载具体状态。

二、类的基本组成

一个类通常由以下几个部分组成:

组成 说明 示例
类名 标识类的名称 User
属性(Attribute) 描述对象的数据特征 name、age
方法(Method) 描述对象能够执行的行为 login()、logout()
构造方法 创建对象时执行初始化逻辑 __init__()、constructor()
访问控制 限制属性和方法的访问范围 public、private

需要注意:并非所有编程语言都以完全相同的方式实现类。例如,Python 的属性访问控制主要依赖命名约定和名称改写机制,而 Java 提供了明确的访问修饰符。

2.1 属性(Attribute)

属性用于描述对象的状态。

例如,一个用户对象可能具有:

User
├── id
├── name
├── age
├── email
└── status

属性可以进一步区分为:

  • 实例属性:属于某个具体对象,不同对象通常拥有各自独立的值。
  • 类属性:属于类本身,通常由该类的多个实例共享。
  • 静态属性:部分语言中用于表示与具体实例无关、归属于类或类型的成员,具体语义依语言而定。
  • 计算属性:通过计算或访问器动态获得的属性,不一定直接存储为独立字段。

以 Python 为例:

class User:
    system_name = "Reverie"  # 类属性

    def __init__(self, name, age):
        self.name = name      # 实例属性
        self.age = age        # 实例属性

创建两个对象:

user1 = User("Alice", 25)
user2 = User("Bob", 30)

print(user1.name)         # Alice
print(user2.name)         # Bob

print(user1.system_name)  # Reverie
print(user2.system_name)  # Reverie

这里:

  • name 和 age 分别保存在不同实例的属性存储中。
  • system_name 定义在类上,两个对象都可以通过属性查找访问它。

需要注意,Python 实例可以通过赋值创建同名实例属性,从而遮蔽类属性:

user1.system_name = "Custom"

print(user1.system_name)  # Custom
print(user2.system_name)  # Reverie
print(User.system_name)   # Reverie

因此,类属性并不意味着实例绝对不能拥有同名属性。

2.2 方法(Method)

方法是定义在类中的行为逻辑,用于操作对象数据或执行特定任务。

例如:

class User:
    def __init__(self, name):
        self.name = name
        self.logged_in = False

    def login(self):
        self.logged_in = True
        print(f"{self.name} 登录成功")

    def logout(self):
        self.logged_in = False
        print(f"{self.name} 已退出")

方法可以分为:

方法类型 作用 Python 示例
实例方法 操作具体实例的数据 def login(self)
类方法 操作类级别的数据或行为 @classmethod
静态方法 提供与实例状态无直接关系的辅助行为 @staticmethod

不同语言对方法的定义和调用规则存在差异。例如,Java 使用 static 声明静态方法,C++ 使用 static 成员函数。

2.3 构造方法(Constructor)

构造方法用于对象创建过程中的初始化。

不同语言的构造机制并不完全相同:

语言 常见构造机制
Python __init__()
Java 与类同名的构造方法
C++ 与类同名的构造函数
JavaScript constructor()
Go 通常使用工厂函数或构造函数约定
Rust 通常使用 new() 等关联函数

以 Java 为例:

public 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);

这里需要区分两个概念:

  • 对象创建:为对象建立运行时表示,并获得所需资源。
  • 对象初始化:为对象的属性设置初始状态,使其满足预期约束。

两者在不同语言中可能由不同机制完成。

例如,Python 的 __new__() 负责创建并返回实例,__init__() 负责初始化已经创建的实例。

三、类与对象的关系

类与对象之间是一种模板与实例的关系。

一个类可以创建多个对象,每个对象都可以拥有独立的实例状态。

flowchart TB
    A["User 类"]
    B["user1 对象"]
    C["user2 对象"]
    D["user3 对象"]

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

    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:#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. 实例方法通常可以访问和修改当前实例的状态。
  4. 类定义本身不等于某个具体对象。
  5. 类与对象的关系不代表所有语言都采用相同的内存布局和实例化机制。

四、对象的创建与实例化

对象的实例化(Instantiation)是根据类定义创建具体对象的过程。

以 Python 为例:

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def get_price(self):
        return self.price


product = Product("Keyboard", 299)

print(product.name)
print(product.get_price())

对象创建过程可以抽象为:

flowchart TB
    A["定义类 Product"]
    B["调用类创建对象"]
    C["分配对象所需资源"]
    D["创建对象实例"]
    E["执行初始化逻辑"]
    F["获得可用对象"]
    G["访问属性与调用方法"]

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

这是概念层面的抽象流程,不代表所有语言都严格按照这些独立步骤执行。

例如:

  • Java 使用 new 创建对象,并执行构造方法。
  • C++ 可以在栈上或动态存储区创建对象。
  • Python 通过调用类对象创建实例。
  • JavaScript 使用 new 调用构造函数,也可以通过对象字面量直接创建对象。
  • Go 通常通过复合字面量或 new 创建结构体实例。

五、对象的三个核心特征

在面向对象理论中,对象通常具有三个重要特征:

5.1 状态(State)

状态描述对象在某个时刻的数据情况。

例如:

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

账户对象的状态可以表示为:

owner = Alice
balance = 1000

当余额发生变化时,对象的状态也随之改变。

account.balance -= 200

新的状态为:

owner = Alice
balance = 800

5.2 行为(Behavior)

行为表示对象能够执行的操作。

例如:

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

    def deposit(self, amount):
        self.balance += amount

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("余额不足")

        self.balance -= amount

deposit() 和 withdraw() 是账户对象的行为。

对象不仅保存数据,也可以通过方法维护自身状态。

5.3 身份(Identity)

身份用于区分不同的对象。

两个对象即使属性值完全相同,也可能是两个不同的对象。

user1 = User("Alice", 25)
user2 = User("Alice", 25)

print(user1 == user2)
print(user1 is user2)

在没有自定义 __eq__() 的情况下,Python 普通对象默认使用身份语义进行相等性判断,因此上述两个表达式通常分别得到:

False
False

如果自定义了 __eq__(),== 可以根据业务规则比较对象内容,而 is 仍然用于判断两个引用是否指向同一个对象。

这揭示了三个容易混淆的概念:

概念 含义
身份(Identity) 对象是否为同一个实体
相等性(Equality) 两个对象的内容或业务含义是否相等
状态(State) 对象当前保存的数据

在设计业务系统时,需要明确判断的是对象身份还是对象值。

例如,两个用户对象的姓名和年龄相同,不代表它们一定对应数据库中的同一个用户记录。

六、对象引用与内存模型

对象通常不是简单的变量值,而是运行时创建的实体。

程序中的变量可能保存对象本身,也可能保存指向对象的引用或句柄,具体取决于语言实现。

以 Python 为例:

user1 = User("Alice", 25)
user2 = user1

user2.name = "Bob"

print(user1.name)  # Bob
print(user2.name)  # Bob

这里 user1 和 user2 指向同一个对象。

flowchart TB
    A["变量 user1"]
    B["变量 user2"]
    C["同一个 User 对象"]
    D["name: Bob"]
    E["age: 25"]

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

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

因此,通过任意一个引用修改对象,都可能影响通过其他引用观察到的结果。

6.1 引用赋值不等于对象复制

这是面向对象编程中非常重要的概念。

user1 = User("Alice", 25)
user2 = user1

上述代码没有创建第二个 User 对象,而是让两个变量引用同一个实例。

如果需要创建一个独立对象,就需要执行复制操作。

import copy

user1 = User("Alice", 25)
user2 = copy.copy(user1)

user2.name = "Bob"

print(user1.name)  # Alice
print(user2.name)  # Bob

不过,浅拷贝只复制外层对象,内部嵌套对象仍可能共享引用。

class Team:
    def __init__(self, members):
        self.members = members


team1 = Team(["Alice", "Bob"])
team2 = copy.copy(team1)

team2.members.append("Carol")

print(team1.members)
print(team2.members)

两个对象的 members 属性引用同一个列表,因此修改其中一个对象的列表,也会影响另一个对象。

如果需要递归复制嵌套对象,可以考虑深拷贝,但深拷贝也可能受到循环引用、自定义复制逻辑以及不可复制资源的影响。

6.2 对象是否一定存储在堆内存?

不一定。

虽然很多面向对象语言会将对象分配在堆内存中,但不能将这一点视为所有语言和所有实现的统一规则。

例如:

  • Java 普通对象通常由 JVM 管理,常见实现中分配在堆上。
  • Python 对象通常由运行时管理,CPython 中大多数对象通过动态内存分配机制管理。
  • C++ 对象可以具有自动存储期、静态存储期或动态存储期。
  • Rust 对象的存储位置取决于其所有权、生命周期及具体使用方式。
  • 编译器还可能通过逃逸分析、标量替换等优化消除实际的堆分配。

因此,类与对象是语言层面的抽象,不能直接等同于某一种固定的内存布局。

七、类属性与实例属性的区别

类属性和实例属性是实际开发中容易混淆的两个概念。

对比维度 类属性 实例属性
归属 类 具体实例
定义位置 类定义内部 通常在实例初始化或运行过程中创建
数据共享 通常由实例共享访问 每个实例可以独立持有
修改影响 取决于语言及属性查找规则 通常只影响当前实例
常见用途 配置、常量、共享计数 用户信息、订单状态、业务数据

Python 示例:

class User:
    user_count = 0

    def __init__(self, name):
        self.name = name
        User.user_count += 1


user1 = User("Alice")
user2 = User("Bob")

print(User.user_count)  # 2

这里 user_count 记录创建的用户实例数量。

但需要注意,类属性并不天然具备线程安全性。如果多个线程同时修改共享状态,就需要考虑同步机制。