【成人版python基础入门】第四章 面向对象初探——代码也能“活”过来

面向对象初探——代码也能“活”过来

在编程的世界里，我们已经学会了如何使用函数和模块来组织代码，解决各种问题。但是，随着程序的复杂度增加，仅仅是函数和模块已经不能满足我们的需求。这时，面向对象编程（Object-Oriented Programming, OOP）就派上了用场。面向对象编程是一种强大的编程范式，通过它，代码仿佛有了生命，变得更加生动和有趣。

类与对象的基本概念

什么是类

类（Class）是面向对象编程中的一个重要概念，它是创建对象的模板。类中定义了数据（属性）和行为（方法），这些数据和行为是所有基于该类创建的对象共有的。

什么是对象

对象（Object）是类的实例。通过实例化类，我们可以创建具体的对象，每个对象具有类中定义的属性和方法。

风趣的例子

假设你是一名厨师，正在学习如何制作不同种类的蛋糕。你可以将每种蛋糕的制作方法和所需材料记录在一个蛋糕食谱中。这个食谱就是类，不同的蛋糕就是基于这个食谱制作出来的对象。

例如，一个食谱（类）可能包含以下内容：

• 材料（属性）：面粉、糖、鸡蛋等。
• 制作方法（方法）：搅拌、烘烤等。

当你遵循这个食谱（类）制作了一个具体蛋糕时，这个蛋糕就是食谱的一个实例（对象）。

定义类与实例化对象

定义类

在 Python 中，使用 class 关键字来定义类。类中可以定义属性和方法。方法是类中的函数，可以访问和修改对象的属性。

class Cake:
    # 类属性
    flavor = "vanilla"

    # 初始化方法
    def __init__(self, size, layers):
        self.size = size
        self.layers = layers

    # 类方法
    def bake(self):
        print(f"正在烘烤一个 {self.flavor} 味的蛋糕，大小为 {self.size}，层数为 {self.layers}。")

    def decorate(self):
        print(f"正在装饰一个 {self.size} 大小，{self.layers} 层数的 {self.flavor} 味蛋糕。")

实例化对象

通过类名后跟一对括号来创建类的实例（对象）。可以在括号中传递参数，这些参数会被传递给类的 __init__ 方法。

# 实例化蛋糕对象
birthday_cake = Cake("large", 3)

# 调用对象的方法
birthday_cake.bake()
birthday_cake.decorate()

这个例子中，Cake 类定义了 flavor、size 和 layers 属性，以及 bake 和 decorate 方法。通过实例化 Cake 类，我们创建了一个 birthday_cake 对象，并调用了它的方法。

类的方法与属性

属性

属性是类中存储数据的变量。属性可以分为类属性和实例属性。

• 类属性：所有实例对象共享的属性，定义在类的外部。
• 实例属性：每个实例对象独有的属性，定义在 __init__ 方法中。

方法

方法是类中的函数，用于定义对象的行为。方法可以访问和修改对象的属性。

• 初始化方法 __init__：在创建对象时自动调用，用于初始化对象的属性。
• 普通方法：定义对象的行为，可以在对象上调用。
• 类方法：使用 @classmethod 装饰器定义，可以通过类或对象调用。
• 静态方法：使用 @staticmethod 装饰器定义，可以通过类或对象调用，但不访问类或对象的属性。

实际代码示例

假设我们要创建一个简单的银行账户类，来演示类的方法和属性的使用。

class BankAccount:
    # 类属性
    bank_name = "WeTab Bank"

    # 初始化方法
    def __init__(self, owner, balance=0.0):
        self.owner = owner
        self.balance = balance

    # 普通方法
    def deposit(self, amount):
        self.balance += amount
        print(f"存款成功，当前余额为: {self.balance}")

    def withdraw(self, amount):
        if amount > self.balance:
            print("余额不足，取款失败。")
        else:
            self.balance -= amount
            print(f"取款成功，当前余额为: {self.balance}")

    # 类方法
    @classmethod
    def change_bank_name(cls, new_name):
        cls.bank_name = new_name
        print(f"银行名称已更改为: {cls.bank_name}")

    # 静态方法
    @staticmethod
    def get_bank_info():
        print("这是一个虚拟银行，只为编程学习使用。")

# 实例化银行账户对象
account1 = BankAccount("Alice", 1000.0)
account2 = BankAccount("Bob")

# 调用实例方法
account1.deposit(500.0)
account1.withdraw(200.0)
account2.deposit(1000.0)

# 调用类方法
BankAccount.change_bank_name("New WeTab Bank")

# 调用静态方法
BankAccount.get_bank_info()

代码详解

1. 类属性：

   bank_name = "WeTab Bank"
   

   bank_name 是一个类属性，所有 BankAccount 对象共享这个属性。

2. 初始化方法：

   def __init__(self, owner, balance=0.0):
       self.owner = owner
       self.balance = balance
   

   __init__ 方法在创建对象时自动调用，用于初始化对象的属性 owner 和 balance。balance 有一个默认值 0.0。

3. 普通方法：

   def deposit(self, amount):
       self.balance += amount
       print(f"存款成功，当前余额为: {self.balance}")
   
   def withdraw(self, amount):
       if amount > self.balance:
           print("余额不足，取款失败。")
       else:
           self.balance -= amount
           print(f"取款成功，当前余额为: {self.balance}")
   

   deposit 和 withdraw 是普通方法，可以访问和修改对象的属性 balance。

4. 类方法：

   @classmethod
   def change_bank_name(cls, new_name):
       cls.bank_name = new_name
       print(f"银行名称已更改为: {cls.bank_name}")
   

   change_bank_name 是一个类方法，用于更改类属性 bank_name。可以通过类或对象调用。

5. 静态方法：

   @staticmethod
   def get_bank_info():
       print("这是一个虚拟银行，只为编程学习使用。")
   

   get_bank_info 是一个静态方法，不访问类或对象的属性。可以通过类或对象调用。

代码样例：创建一个“宠物猫”类

为了让你更好地体验面向对象编程的优势，我们来创建一个“宠物猫”类，通过类和对象展示虚拟养猫的乐趣。

定义“宠物猫”类

class Cat:
    # 类属性
    species = "Felis catus"

    # 初始化方法
    def __init__(self, name, age, color):
        self.name = name
        self.age = age
        self.color = color
        self.hunger_level = 5  # 默认饥饿等级为 5，满值为 10
        self.happiness_level = 5  # 默认幸福等级为 5，满值为 10

    # 普通方法
    def meow(self):
        print(f"{self.name} 喵喵叫。")

    def eat(self, food_amount):
        if food_amount > 0:
            self.hunger_level -= food_amount
            if self.hunger_level < 0:
                self.hunger_level = 0
            print(f"{self.name} 吃了 {food_amount} 份食物，饥饿等级降至 {self.hunger_level}。")
        else:
            print(f"{self.name} 没有吃到食物，饥饿等级保持不变。")

    def play(self, play_time):
        if play_time > 0:
            self.happiness_level += play_time
            if self.happiness_level > 10:
                self.happiness_level = 10
            print(f"{self.name} 玩了 {play_time} 分钟，幸福等级升至 {self.happiness_level}。")
        else:
            print(f"{self.name} 没有玩，幸福等级保持不变。")

    def sleep(self, hours):
        if hours > 0:
            self.hunger_level += hours
            if self.hunger_level > 10:
                self.hunger_level = 10
            self.happiness_level -= hours
            if self.happiness_level < 0:
                self.happiness_level = 0
            print(f"{self.name} 睡了 {hours} 小时，饥饿等级升至 {self.hunger_level}，幸福等级降至 {self.happiness_level}。")
        else:
            print(f"{self.name} 没有睡，状态保持不变。")

    # 类方法
    @classmethod
    def describe_species(cls):
        print(f"所有猫的种类是 {cls.species}。")

    # 静态方法
    @staticmethod
    def get_care_tips():
        print("照顾猫咪的小贴士：及时喂食、定期玩耍、保持清洁。")

实例化“宠物猫”对象

# 实例化宠物猫对象
kitteh = Cat("Kitteh", 3, "white")

与宠物猫互动

# 与宠物猫互动
kitteh.meow()
kitteh.eat(3)
kitteh.play(2)
kitteh.sleep(4)

# 查看宠物猫的状态
print(f"{kitteh.name} 饥饿等级: {kitteh.hunger_level}")
print(f"{kitteh.name} 幸福等级: {kitteh.happiness_level}")

# 调用类方法和静态方法
Cat.describe_species()
Cat.get_care_tips()

运行结果

假设你运行了上面的代码，程序会创建一个名为 Kitteh 的宠物猫对象，并与它进行互动。宠物猫会喵喵叫、吃东西、玩耍和睡觉，最后程序会显示宠物猫的状态。

例如：

Kitteh 喵喵叫。
Kitteh 吃了 3 份食物，饥饿等级降至 2。
Kitteh 玩了 2 分钟，幸福等级升至 7。
Kitteh 睡了 4 小时，饥饿等级升至 6，幸福等级降至 3。
Kitteh 饥饿等级: 6
Kitteh 幸福等级: 3
所有猫的种类是 Felis catus。
照顾猫咪的小贴士：及时喂食、定期玩耍、保持清洁。

面向对象编程的优势

1. 代码重用：通过定义类，可以创建多个具有相同属性和方法的对象，避免重复编写代码。
2. 封装：将数据和行为封装在类中，可以保护数据不被外部直接访问和修改，提高代码的安全性。
3. 继承：类可以继承其他类的属性和方法，扩展和重用已有的功能。
4. 多态：不同的对象可以以不同的方式响应相同的方法调用，使代码更具灵活性和可扩展性。

代码重用

通过定义 Cat 类，我们可以轻松创建多个宠物猫对象，每个对象都具有相同的属性和方法。

kitteh = Cat("Kitteh", 3, "white")
milo = Cat("Milo", 2, "black")

封装

Cat 类中定义了 __init__ 方法来初始化对象的属性，并通过普通方法来修改这些属性。外部代码不能直接修改对象的属性，只能通过方法来访问和修改。

# 错误的直接修改属性
# kitteh.hunger_level = -1  # 不推荐这样做，直接修改属性可能违反业务逻辑

# 正确的通过方法修改属性
kitteh.eat(3)

继承

假设我们想创建一个更具体的宠物猫类，如 SiameseCat（暹罗猫），可以继承 Cat 类，并添加特定的方法。

class SiameseCat(Cat):
    def __init__(self, name, age, color, eye_color="blue"):
        super().__init__(name, age, color)
        self.eye_color = eye_color

    def meow(self):
        print(f"{self.name} 发出低沉的喵喵声。")

# 实例化暹罗猫对象
luna = SiameseCat("Luna", 4, "white", "green")
luna.meow()

多态

不同的对象可以以不同的方式响应相同的方法调用，提高代码的灵活性。

def interact_with_cat(cat):
    cat.meow()

# 与不同种类的猫互动
interact_with_cat(kitteh)  # 输出：Kitteh 喵喵叫。
interact_with_cat(luna)    # 输出：Luna 发出低沉的喵喵声。

摘要

面向对象编程是一种强大的编程范式，通过它，代码仿佛有了生命。本文带你体验了创建类与对象的乐趣，让程序更加生动和有趣。通过学习面向对象编程的基本概念，你可以更好地组织和管理代码，提高代码的可重用性、安全性和灵活性。

• 类与对象：类是创建对象的模板，对象是类的实例。
• 定义类：使用 class 关键字定义类，可以在类中定义属性和方法。
• 实例化对象：通过类名后跟一对括号来创建类的实例。
• 类的方法与属性：属性用于存储数据，方法用于定义对象的行为。
• 代码样例：创建了一个“宠物猫”类，体验了虚拟养猫的乐趣。
• 面向对象编程的优势：代码重用、封装、继承和多态。

希望这篇教程能为你与 Python 的旅途带来更多的乐趣和信心。面向对象编程是编程中不可或缺的一部分，掌握面向对象的基本技巧，将使你在处理实际问题时更加得心应手。让我们继续前行，探索更多 Python 的功能和编程技巧，让你的代码更加生动有趣。🐾👩‍💻🌟