2025 Y 微进阶之 “类” 深度解析 —— 从数据封装到面向对象架构实践

一、类的基础概念

实质就是把相同类型的函数封装起来共享数据。

二、类的创建与使用

（一）创建类的语法结构

用 class 关键字定义类，格式如下：

class 类名:
    """类的说明文档（可选，用于描述类功能）"""
    def __init__(self, 参数1, 参数2...):  
        # 初始化方法，创建对象时自动执行，用于初始化对象属性
        self.属性1 = 参数1  
        self.属性2 = 参数2  

    def 方法名1(self, 参数...):  
        # 自定义方法，实现具体功能
        代码块

关键说明：

class 是定义类的关键字，类名首字母建议大写（区分函数）。
__init__ 是初始化方法（构造函数），创建对象时自动调用，self 代表对象自身（类似 “我”，指代当前实例）。
方法里通过 self.属性 定义对象的属性，后续可通过对象访问、修改。

import time  # 用于获取当前时间

class Microwave:
    """微波炉类，模拟微波炉的功能和属性"""
    def __init__(self, name):
        # 初始化属性：微波炉名称、购买时间
        self.name = name  
        self.time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())  

    def print_info(self):
        # 自定义方法：打印微波炉信息
        print('微波炉的名字:', self.name, '\n', '购买时间:', self.time)  

    def bread(self, temp=3):
        # 自定义方法：模拟烤面包，temp 为默认参数（时长，分钟）
        self.temp = temp  
        print("开始烤面包，时长:", self.temp, '分钟')

功能说明：

__init__：创建对象时，传入 name 初始化名称，自动获取当前时间存为 self.time。
print_info：打印微波炉名称和购买时间。
bread：模拟烤面包功能，temp 设默认值 3，执行时给对象新增 self.temp 属性。

（三）创建对象并调用方法

1. 创建对象语法

对象名 = 类名(实参)

解释：类名(实参) 会触发 __init__ 方法，实参传给 __init__ 的参数（self 不用传，Python 自动处理）。

2. 调用对象方法语法

对象名.方法名(参数)

微波炉的名字: zhangsan 
 购买时间: 2025-07-07 10:00:00（时间随实际运行变化）
开始烤面包，时长: 3 分钟

三、类的属性操作

（一）属性的访问

类的属性通过 对象.属性 访问，比如：

a = Microwave('zhangsan')  
# 访问 name 属性
print(a.name)  
# 访问 time 属性
print(a.time)

注意：若属性在方法（如 bread）里定义，需先调用方法才会创建属性，否则报错。比如直接 print(a.temp) 会报错，需先执行 a.bread() 再访问。

（二）属性的修改

直接通过赋值修改属性值，示例：

a = Microwave('zhangsan')  
# 修改 name 属性
a.name = 'lisi'  
# 修改 time 属性（注意：实际开发建议通过方法规范修改，这里仅演示基础用法）
a.time = '2022年6月7日'  
print(a.name, a.time)

执行结果：

lisi 2022年6月7日

（三）初始化方法调用其他方法

__init__ 里可调用类的其他方法，让对象创建时自动执行功能。修改微波炉类示例：

import time

class Microwave:
    def __init__(self, name):
        self.name = name  
        self.time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())  
        # 初始化时调用 bread 方法，自动执行烤面包逻辑
        self.bread()  

    def print_info(self):
        print('微波炉的名字:', self.name, '\n', '购买时间:', self.time)  

    def bread(self, temp=3):
        self.temp = temp  
        print("开始烤面包，时长:", self.temp, '分钟')

执行验证：

四、类的继承

# 父类：定义通用属性和方法
class ParentClass:
    def __init__(self, name):
        self.name = name
        print(f"父类初始化，名称: {self.name}")

    def parent_method(self):
        print("这是父类的方法")

# 子类：继承父类，可复用父类内容
class ChildClass(ParentClass):
    pass  # 暂时不写内容，纯继承

验证继承：

# 创建子类对象，传入参数触发父类 __init__
c = ChildClass("测试")  
# 调用父类方法
c.parent_method()

执行结果：

父类初始化，名称: 测试（父类 __init__ 执行）  
这是父类的方法（父类方法执行）

（二）继承的本质逻辑

子类创建对象时，先找自己的 __init__，若没有，会自动调用父类的 __init__ 初始化。子类能直接用父类的属性（如 self.name ）和方法（如 parent_method ），就像 “天生自带” 的能力。

三、子类中添加新方法

（一）添加方法的意义

让子类在父类基础上，拓展专属功能。比如父类是 “手机”（有 “打电话” 方法），子类 “智能手机” 继承后，新增 “扫码付款”“人脸识别” 等方法，实现功能升级。

（二）代码示例（父类 + 子类新增方法）

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

    def parent_work(self):
        print(f"父类通用工作：{self.name} 执行基础任务")

# 子类继承并新增方法
class ChildClass(ParentClass):
    def child_work(self):
        print(f"子类专属工作：{self.name} 执行定制任务")

验证新增方法：

c = ChildClass("任务执行者")  
# 调用父类方法
c.parent_work()  
# 调用子类新增方法
c.child_work()

执行结果：

父类通用工作：任务执行者 执行基础任务（父类方法）  
子类专属工作：任务执行者 执行定制任务（子类新增方法）

四、覆盖（重写）父类方法

（一）覆盖的作用

子类想改变父类方法的逻辑，就 “重写” 父类方法。比如父类 “动物” 的 “移动” 是 “用脚走”，子类 “蛇” 继承后，重写 “移动” 为 “用肚子爬”，让逻辑更贴合子类特性。

（二）覆盖的实现（同名方法替换）

子类定义和父类同名的方法，自动覆盖父类逻辑。示例：

class ParentClass:
    def action(self):
        print("父类默认行为：缓慢移动")

class ChildClass(ParentClass):
    # 重写父类 action 方法
    def action(self):
        print("子类覆盖行为：快速冲刺")

验证覆盖效果：

c = ChildClass()  
# 调用方法，执行子类重写后的逻辑
c.action()

执行结果：

子类覆盖行为：快速冲刺（父类方法被覆盖）

（三）调用父类被覆盖的方法（super 关键字）

有时子类重写方法时，想保留父类部分逻辑，可用 super() 调用父类原方法。示例：

class ParentClass:
    def action(self):
        print("父类基础动作")

class ChildClass(ParentClass):
    def action(self):
        # 先调用父类 action 方法
        super().action()  
        print("子类补充动作")

c = ChildClass()  
c.action()

父类基础动作（父类方法逻辑）  
子类补充动作（子类新增逻辑）