Python面向对象编程必学概念：从饼干模型理解OOP（小白友好版）

最新推荐文章于 2025-05-16 15:20:46 发布

南部余额

最新推荐文章于 2025-05-16 15:20:46 发布

阅读量564

点赞数 20

分类专栏： python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_33181292/article/details/147994416

版权

python 专栏收录该内容

11 篇文章

订阅专栏

Python面向对象编程核心概念：小白友好指南

Python面向对象编程核心概念：小白友好指南

1. 类和对象：数字世界中的模具和产品

简单解释：

类(Class) 就像是一个模具或蓝图，描述了某类事物的特点和行为
对象(Object) 是根据类创建的具体实例，就像用模具制作出的产品

示例：想象你在做饼干

# 定义饼干模具(类)
class Cookie:
    # 初始化方法，设置饼干的基本属性
    def __init__(self, flavor, shape):
        self.flavor = flavor  # 口味
        self.shape = shape    # 形状
        self.is_baked = False # 是否已烤好
    
    # 烤饼干的方法
    def bake(self):
        print(f"烤一块{self.shape}形状的{self.flavor}口味饼干")
        self.is_baked = True
    
    # 吃饼干的方法
    def eat(self):
        if self.is_baked:
            print(f"真好吃！这块{self.flavor}饼干")
        else:
            print("这饼干还没烤呢！")

# 制作具体的饼干(对象)
chocolate_star = Cookie("巧克力", "星形")  # 第一块饼干
vanilla_heart = Cookie("香草", "心形")    # 第二块饼干

# 使用饼干对象
chocolate_star.bake()  # 输出：烤一块星形形状的巧克力口味饼干
chocolate_star.eat()   # 输出：真好吃！这块巧克力饼干

vanilla_heart.eat()    # 输出：这饼干还没烤呢！

2. 继承：让代码有家族血统

简单解释：

继承让一个类可以获得另一个类的属性和方法
就像孩子会继承父母的某些特征，但也可以有自己的特点

示例：各种饼干的家族谱系

# 基础饼干类(父类)
class Cookie:
    def __init__(self, shape):
        self.shape = shape
        self.is_baked = False
    
    def bake(self):
        print(f"烤一块{self.shape}形状的普通饼干")
        self.is_baked = True

# 巧克力饼干类(子类)
class ChocolateCookie(Cookie):
    def __init__(self, shape, chocolate_type):
        # 调用父类的初始化方法
        super().__init__(shape)
        # 添加独有属性
        self.chocolate_type = chocolate_type
    
    # 重写父类的方法
    def bake(self):
        print(f"烤一块{self.shape}形状的{self.chocolate_type}巧克力饼干")
        self.is_baked = True
    
    # 添加独有方法
    def add_chocolate_chips(self):
        print(f"在饼干上添加{self.chocolate_type}巧克力豆")

# 创建并使用巧克力饼干
dark_chocolate = ChocolateCookie("圆形", "黑巧克力")
dark_chocolate.add_chocolate_chips()  # 输出：在饼干上添加黑巧克力巧克力豆
dark_chocolate.bake()                # 输出：烤一块圆形形状的黑巧克力巧克力饼干

# 创建普通饼干
simple_cookie = Cookie("方形")
simple_cookie.bake()  # 输出：烤一块方形形状的普通饼干
# simple_cookie.add_chocolate_chips()  # 这会报错，因为普通饼干没有这个方法

3. 封装：把细节包起来

简单解释：

封装是隐藏对象内部实现细节，只暴露必要的接口
就像使用微波炉，你不需要知道内部电路如何工作，只需按按钮

示例：饼干厂的生产流程

class CookieFactory:
    def __init__(self):
        # 约定：单下划线开头表示"受保护"的属性，不应直接访问
        self._temperature = 180
        # 约定：双下划线开头会被Python改名，更难直接访问
        self.__secret_recipe = "特殊配方：糖和香料"
    
    # 公开方法，用于生产饼干
    def make_cookies(self, flavor, count):
        self._preheat_oven()
        dough = self._prepare_dough(flavor)
        cookies = self._bake_cookies(dough, count)
        return cookies
    
    # 内部方法，不期望外部直接调用
    def _preheat_oven(self):
        print(f"预热烤箱到{self._temperature}度")
    
    def _prepare_dough(self, flavor):
        print(f"根据{self.__secret_recipe}准备{flavor}口味的面团")
        return f"{flavor}面团"
    
    def _bake_cookies(self, dough, count):
        print(f"烘烤{count}块{dough}饼干")
        return f"{count}块成品饼干"

# 使用饼干工厂
factory = CookieFactory()
cookies = factory.make_cookies("草莓", 5)  # 正常使用公开接口
print(f"拿到了{cookies}")

# 尝试访问内部属性/方法(不推荐)
# factory._preheat_oven()  # 可以访问但不推荐
# print(factory._temperature)  # 可以访问但不推荐
# print(factory.__secret_recipe)  # 会报错！
# 实际上秘方被改名为：_CookieFactory__secret_recipe
print(factory._CookieFactory__secret_recipe)  # 这样可以访问，但强烈不推荐！

4. 多态：同一动作，不同表现

简单解释：

多态让不同类的对象对同一消息作出不同响应
就像按下"开始"按钮，洗衣机开始洗衣，微波炉开始加热

示例：不同甜点的制作方式

class Dessert:
    def __init__(self, name):
        self.name = name
    
    def prepare(self):
        print(f"准备制作{self.name}")
    
    def make(self):
        # 基类方法，将被子类重写
        print("制作一般甜点")
    
    def serve(self):
        self.prepare()
        self.make()
        print(f"{self.name}已上桌，请享用！")

class Cookie(Dessert):
    def make(self):
        print(f"烘培{self.name}饼干")

class IceCream(Dessert):
    def make(self):
        print(f"冷冻{self.name}冰淇淋")

class Cake(Dessert):
    def make(self):
        print(f"烘焙并装饰{self.name}蛋糕")

# 创建不同的甜点
desserts = [
    Cookie("巧克力"), 
    IceCream("草莓"),
    Cake("生日")
]

# 统一处理所有甜点
for dessert in desserts:
    dessert.serve()
    print("-----")

# 输出结果:
# 准备制作巧克力
# 烘培巧克力饼干
# 巧克力已上桌，请享用！
# -----
# 准备制作草莓
# 冷冻草莓冰淇淋
# 草莓已上桌，请享用！
# -----
# 准备制作生日
# 烘焙并装饰生日蛋糕
# 生日已上桌，请享用！
# -----

5. 抽象类：规定规则的模板

简单解释：

抽象类 是不能直接创建对象的类，用来定义子类必须实现的方法
就像是一份合同或食谱，规定了必须包含的内容

示例：甜点制作标准

from abc import ABC, abstractmethod

class Dessert(ABC):  # ABC = Abstract Base Class (抽象基类)
    def __init__(self, name):
        self.name = name
    
    @abstractmethod  # 抽象方法，子类必须实现
    def make(self):
        pass  # 不提供实现
    
    def serve(self):
        print(f"准备{self.name}")
        self.make()  # 调用子类实现的方法
        print(f"{self.name}已上桌！")

# 以下代码会出错，因为不能实例化抽象类
# generic_dessert = Dessert("普通甜点")  # 错误！

# 正确的做法是创建子类并实现抽象方法
class Cookie(Dessert):
    # 必须实现make方法，否则会出错
    def make(self):
        print(f"烘培{self.name}饼干")

# 现在可以创建Cookie对象了
chocolate_cookie = Cookie("巧克力")
chocolate_cookie.serve()

6. 组合：把不同功能组合到一起

简单解释：

组合是在一个类中包含其他类的对象
就像电脑包含CPU、内存和硬盘等组件

示例：制作一个甜品礼盒

class Cookie:
    def __init__(self, flavor):
        self.flavor = flavor
    
    def describe(self):
        return f"{self.flavor}口味饼干"

class Chocolate:
    def __init__(self, type_):
        self.type = type_
    
    def describe(self):
        return f"{self.type}巧克力"

class DessertBox:
    def __init__(self, name):
        self.name = name
        self.contents = []  # 用来存放礼盒中的甜点
    
    def add_item(self, item):
        self.contents.append(item)
    
    def describe(self):
        print(f"{self.name}礼盒包含:")
        if not self.contents:
            print("  (空)")
        else:
            for item in self.contents:
                print(f"  - {item.describe()}")

# 创建并填充礼盒
gift_box = DessertBox("节日快乐")
gift_box.add_item(Cookie("香草"))
gift_box.add_item(Cookie("巧克力"))
gift_box.add_item(Chocolate("黑巧"))
gift_box.add_item(Chocolate("白巧"))

# 查看礼盒内容
gift_box.describe()

7. 类方法和静态方法：特殊工具

简单解释：

类方法(Class Method) 操作类本身，而不是实例
静态方法(Static Method) 不操作类也不操作实例，就像放在类中的普通函数

示例：饼干工厂的辅助功能

class Cookie:
    # 类变量
    all_flavors = ["巧克力", "香草", "草莓", "柠檬"]
    cookie_count = 0
    
    def __init__(self, flavor):
        if flavor not in Cookie.all_flavors:
            raise ValueError(f"不支持的口味: {flavor}")
        self.flavor = flavor
        Cookie.cookie_count += 1
    
    # 实例方法 - 使用self
    def eat(self):
        print(f"吃了一块{self.flavor}饼干")
        Cookie.cookie_count -= 1
    
    # 类方法 - 使用cls参数
    @classmethod
    def get_cookie_count(cls):
        return f"现在有{cls.cookie_count}块饼干"
    
    # 类方法创建实例
    @classmethod
    def create_chocolate(cls):
        return cls("巧克力")  # 等同于 Cookie("巧克力")
    
    # 静态方法 - 不使用self或cls
    @staticmethod
    def is_valid_flavor(flavor):
        return flavor in Cookie.all_flavors
    
    @staticmethod
    def baking_instructions():
        return "在180度烤箱中烤15分钟"

# 使用类方法和静态方法
print(Cookie.is_valid_flavor("香草"))  # 输出: True
print(Cookie.is_valid_flavor("薄荷"))  # 输出: False
print(Cookie.baking_instructions())   # 输出烘焙指南

# 创建几块饼干
c1 = Cookie("巧克力")
c2 = Cookie("草莓")
c3 = Cookie.create_chocolate()  # 使用类方法创建

print(Cookie.get_cookie_count())  # 输出：现在有3块饼干

c1.eat()  # 吃掉一块
print(Cookie.get_cookie_count())  # 输出：现在有2块饼干

8. 属性装饰器：优雅地访问属性

简单解释：

属性(Property) 让方法像属性一样被访问，可以添加获取/设置值的逻辑

示例：饼干制作的安全检查

class Cookie:
    def __init__(self, flavor, size_cm):
        self.flavor = flavor
        # 使用下划线表示这是内部属性
        self._size_cm = size_cm
        self._is_baked = False
    
    # 将方法变成可读属性
    @property
    def size_cm(self):
        return self._size_cm
    
    # size_cm的设置器
    @size_cm.setter
    def size_cm(self, value):
        if value <= 0:
            raise ValueError("饼干尺寸必须大于0")
        if self._is_baked:
            print("警告：饼干已烤好，不能改变大小")
            return
        self._size_cm = value
    
    # is_baked只读属性
    @property
    def is_baked(self):
        return self._is_baked
    
    # 烤饼干
    def bake(self):
        print(f"烤一块{self.size_cm}cm的{self.flavor}饼干")
        self._is_baked = True

# 创建饼干
cookie = Cookie("巧克力", 5)

# 像访问属性一样使用属性
print(f"饼干尺寸: {cookie.size_cm}cm")  # 使用getter

# 修改属性
cookie.size_cm = 7  # 使用setter
print(f"新饼干尺寸: {cookie.size_cm}cm")

# 烤饼干
cookie.bake()

# 尝试修改已烤好的饼干
cookie.size_cm = 10  # 会显示警告

# 尝试非法值
try:
    cookie.size_cm = -5  # 引发ValueError
except ValueError as e:
    print(f"出错: {e}")

# 尝试修改只读属性
try:
    cookie.is_baked = False  # 这会失败，因为没有setter
except AttributeError as e:
    print(f"出错: {e}")