7.1 类与对象基础

7.1.1 理论知识

面向对象编程（OOP）是一种编程范式，它将数据（属性）和操作数据的函数（方法）封装在一起，形成一个称为类（Class）的结构。类是对象（Object）的蓝图，对象是类的实例。

在Python中，使用 class 关键字定义类。类可以包含属性（变量）和方法（函数）。属性用于描述对象的特征，方法用于定义对象的行为。

7.1.2 示例代码

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print(f"{self.name} 汪汪叫！")


# 创建 Dog 类的实例
my_dog = Dog("Buddy", 3)
print(f"我的狗叫 {my_dog.name}，它 {my_dog.age} 岁了。")
my_dog.bark()

7.1.3 代码解释

• 使用 class 关键字定义了 Dog 类。
• __init__ 方法是类的构造函数，在创建类的实例时自动调用。它接受 self 参数（在实例方法中，self 代表实例本身），以及外部传入的 name 和 age 参数，用于初始化对象的属性 self.name 和 self.age。
• bark 方法是 Dog 类的实例方法，用于定义狗叫的行为，它通过 self.name 访问对象的属性并打印相关信息。
• 创建 Dog 类的实例 my_dog，传入名字 Buddy 和年龄 3。然后通过实例访问属性 name 和 age 并打印信息，接着调用 bark 方法让狗叫。

7.2 类的属性与方法

7.2.1 实例属性

理论知识：实例属性是每个对象独有的数据，通过在构造函数 __init__ 中使用 self 关键字定义。不同的对象实例，其对应的实例属性可以有不同的值。

示例代码：

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color


car1 = Car("Toyota", "Red")
car2 = Car("Ford", "Blue")
print(f"第一辆车是 {car1.brand}，颜色为 {car1.color}")
print(f"第二辆车是 {car2.brand}，颜色为 {car2.color}")

代码解释：Car 类的构造函数 __init__ 定义了两个实例属性 brand 和 color。创建 car1 和 car2 两个不同的 Car 实例，它们各自有不同的品牌和颜色属性值。

7.2.2 类属性

理论知识：类属性是所有类的实例共享的属性，定义在类内部但在所有方法之外。对类属性的修改会影响所有实例。

示例代码：

class Circle:
    pi = 3.14159

    def __init__(self, radius):
        self.radius = radius

    def calculate_area(self):
        return Circle.pi * self.radius ** 2


circle1 = Circle(5)
circle2 = Circle(3)
print(f"圆1的面积: {circle1.calculate_area()}")
print(f"圆2的面积: {circle2.calculate_area()}")

代码解释：Circle 类定义了一个类属性 pi，表示圆周率。所有 Circle 类的实例都共享这个 pi 值。calculate_area 方法使用类属性 pi 和实例属性 radius 来计算圆的面积。

7.2.3 实例方法

理论知识：实例方法是定义在类内部，第一个参数为 self 的函数。它可以访问和修改实例的属性，并且不同实例调用实例方法时，self 指向不同的实例对象。

示例代码：已在前面 Dog 类和 Car 类的示例中体现，如 Dog 类的 bark 方法和 Circle 类的 calculate_area 方法，都是实例方法，它们通过 self 访问实例的属性。

7.2.4 类方法

理论知识：类方法是使用 @classmethod 装饰器定义的方法，它的第一个参数通常命名为 cls，代表类本身，而不是实例。类方法可以访问和修改类属性，但不能直接访问实例属性。

示例代码：

class Book:
    total_books = 0

    def __init__(self, title):
        self.title = title
        Book.total_books += 1

    @classmethod
    def get_total_books(cls):
        return cls.total_books


book1 = Book("Python 编程入门")
book2 = Book("数据结构与算法")
print(f"总书籍数量: {Book.get_total_books()}")

代码解释：Book 类有一个类属性 total_books 用于记录创建的书籍总数。构造函数 __init__ 在创建新实例时增加 total_books 的值。get_total_books 类方法通过 cls 参数访问类属性 total_books 并返回其值。

7.2.5 静态方法

理论知识：静态方法是使用 @staticmethod 装饰器定义的方法，它既不访问实例属性也不访问类属性，与类和实例没有直接关联，只是在逻辑上属于类。

示例代码：

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b


result1 = MathUtils.add(3, 5)
result2 = MathUtils.multiply(2, 4)
print(f"加法结果: {result1}")
print(f"乘法结果: {result2}")

代码解释：MathUtils 类定义了两个静态方法 add 和 multiply，它们执行基本的数学运算，不依赖于类或实例的状态，直接通过类名调用。

7.3 继承

7.3.1 理论知识

继承是面向对象编程的重要特性之一，它允许一个类（子类）从另一个类（父类）获取属性和方法，从而实现代码的复用。子类可以继承父类的所有非私有属性和方法，并且可以根据需要添加新的属性和方法，或者重写父类的方法。

在Python中，定义子类时，将父类作为参数传递给 class 关键字后的括号内。

7.3.2 示例代码

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

    def speak(self):
        print(f"{self.name} 发出声音。")


class Dog(Animal):
    def bark(self):
        print(f"{self.name} 汪汪叫！")


class Cat(Animal):
    def meow(self):
        print(f"{self.name} 喵喵叫！")


my_dog = Dog("Buddy")
my_dog.speak()
my_dog.bark()

my_cat = Cat("Whiskers")
my_cat.speak()
my_cat.meow()

7.3.3 代码解释

• 定义了 Animal 类作为父类，它有一个构造函数 __init__ 初始化 name 属性，以及一个 speak 方法。
• Dog 类和 Cat 类继承自 Animal 类，它们自动拥有 Animal 类的 name 属性和 speak 方法。
• Dog 类添加了自己特有的 bark 方法，Cat 类添加了 meow 方法。
• 创建 Dog 类和 Cat 类的实例 my_dog 和 my_cat，分别调用它们从父类继承的 speak 方法以及自身特有的方法。

7.4 多态

7.4.1 理论知识

多态是指同一个方法调用，在不同的对象上会产生不同的行为。这依赖于继承和方法重写。当子类重写了父类的方法后，不同子类的实例调用相同名称的方法时，会执行各自重写后的方法。

7.4.2 示例代码

class Shape:
    def area(self):
        pass


class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height


class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        import math
        return math.pi * self.radius ** 2


shapes = [Rectangle(5, 3), Circle(4)]
for shape in shapes:
    print(f"该形状的面积是: {shape.area()}")

7.4.3 代码解释

• 定义了 Shape 类作为基类，它有一个抽象的 area 方法（这里只是定义，没有具体实现，使用 pass 占位）。
• Rectangle 类和 Circle 类继承自 Shape 类，并分别重写了 area 方法来计算各自形状的面积。
• 创建了一个包含 Rectangle 和 Circle 实例的列表 shapes，通过遍历这个列表并调用每个对象的 area 方法，根据对象的实际类型，会执行对应的 area 方法实现，从而体现多态性。

7.5 封装

7.5.1 理论知识

封装是将数据和操作数据的方法包装在一起，同时限制对某些属性和方法的直接访问，以保护数据的完整性和安全性。在Python中，通过在属性或方法名前加上单下划线 _ 或双下划线 __ 来表示不同程度的封装。

• 单下划线 _ 开头的属性或方法，约定为受保护的成员，虽然仍可以从外部访问，但表示不应该直接访问，而是通过类的公共方法来操作。
• 双下划线 __ 开头的属性或方法，会进行名称改写（name mangling），在外部不能直接访问，进一步加强封装性。

7.5.2 示例代码

class BankAccount:
    def __init__(self, balance):
        self._balance = balance  # 受保护属性

    def deposit(self, amount):
        self._balance += amount
        print(f"存入 {amount}，当前余额: {self._balance}")

    def withdraw(self, amount):
        if amount <= self._balance:
            self._balance -= amount
            print(f"取出 {amount}，当前余额: {self._balance}")
        else:
            print("余额不足")


class SecretBankAccount(BankAccount):
    def __init__(self, balance, password):
        super().__init__(balance)
        self.__password = password  # 私有属性

    def check_password(self, input_password):
        return input_password == self.__password


account = BankAccount(1000)
account.deposit(500)
account.withdraw(300)

secret_account = SecretBankAccount(2000, "123456")
if secret_account.check_password("123456"):
    secret_account.deposit(1000)
else:
    print("密码错误，无法操作")

7.5.3 代码解释

• BankAccount 类有一个受保护属性 _balance，通过 deposit 和 withdraw 公共方法来操作余额，外部不建议直接访问 _balance。
• SecretBankAccount 类继承自 BankAccount 类，添加了一个私有属性 __password，通过 check_password 方法来验证密码，外部不能直接访问 __password。
• 创建 BankAccount 实例 account 并调用公共方法进行存款和取款操作。创建 SecretBankAccount 实例 secret_account，先验证密码，密码正确时才允许进行存款操作。