面向对象编程篇

一、思维导图

二、详细内容

第 6 章：面向对象编程基础

6.1 面向对象编程的概念和优势

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将数据和操作数据的方法封装在一起，形成对象。对象之间通过消息传递进行交互。

优势：

• 可维护性：代码结构清晰，易于理解和修改。
• 可扩展性：可以通过继承和多态方便地扩展功能。
• 可重用性：可以复用已有的类和对象。

6.2 类和对象的定义与创建

在 Python 中，使用 class 关键字定义类，类是对象的蓝图，对象是类的实例。

# 定义一个简单的类
class Person:
    pass

# 创建对象
p1 = Person()
p2 = Person()

6.3 类的属性和方法

类的属性是类的特征，方法是类的行为。

class Person:
    # 类属性
    species = "Homo sapiens"

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

    # 实例方法
    def introduce(self):
        print(f"Hi, my name is {self.name} and I'm {self.age} years old.")

p = Person("Alice", 25)
print(p.species)  # 访问类属性
p.introduce()  # 调用实例方法

6.4 构造函数（init）和析构函数（del）

• 构造函数：__init__ 方法在创建对象时自动调用，用于初始化对象的属性。
• 析构函数：__del__ 方法在对象被销毁时自动调用。

class Person:
    def __init__(self, name):
        self.name = name
        print(f"{self.name} is created.")

    def __del__(self):
        print(f"{self.name} is destroyed.")

p = Person("Bob")
del p

6.5 封装、继承和多态的实现

• 封装：将数据和操作数据的方法封装在一起，隐藏对象的内部实现细节。
• 继承：子类可以继承父类的属性和方法，从而实现代码的复用。
• 多态：不同的对象可以对同一消息做出不同的响应。

# 封装
class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # 私有属性

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

    def get_balance(self):
        return self.__balance

# 继承
class SavingsAccount(BankAccount):
    def __init__(self, balance, interest_rate):
        super().__init__(balance)
        self.interest_rate = interest_rate

    def calculate_interest(self):
        return self.get_balance() * self.interest_rate

# 多态
class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

def make_animal_speak(animal):
    animal.speak()

dog = Dog()
cat = Cat()
make_animal_speak(dog)
make_animal_speak(cat)

第 7 章：高级面向对象编程

7.1 类的特殊方法（如 str、len 等）

特殊方法以双下划线开头和结尾，用于实现对象的特殊行为。

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

    def __str__(self):
        return f"{self.title} by {self.author}"

    def __len__(self):
        return self.pages

book = Book("Python Crash Course", "Eric Matthes", 500)
print(book)  # 调用 __str__ 方法
print(len(book))  # 调用 __len__ 方法

7.2 类的静态方法和类方法

• 静态方法：使用 @staticmethod 装饰器定义，不需要实例化对象就可以调用，与类和实例无关。
• 类方法：使用 @classmethod 装饰器定义，第一个参数是类本身，通常用于创建类的实例。

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

    @classmethod
    def create_from_list(cls, numbers):
        return sum(numbers)

print(MathUtils.add(2, 3))  # 调用静态方法
print(MathUtils.create_from_list([1, 2, 3]))  # 调用类方法

7.3 抽象基类和抽象方法

抽象基类是包含抽象方法的类，抽象方法是没有实现的方法，子类必须实现这些抽象方法。

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

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

    def area(self):
        return 3.14 * self.radius ** 2

circle = Circle(5)
print(circle.area())

7.4 多重继承和方法解析顺序（MRO）

多重继承是指一个子类可以继承多个父类的属性和方法。方法解析顺序（MRO）决定了在多重继承中调用方法的顺序。

class A:
    def method(self):
        print("A's method")

class B:
    def method(self):
        print("B's method")

class C(A, B):
    pass

c = C()
c.method()  # 调用 A 的方法，因为 A 在 MRO 中排在前面
print(C.mro())  # 查看 MRO

三、总结

面向对象编程是一种强大的编程范式，它通过封装、继承和多态等特性，提高了代码的可维护性、可扩展性和可重用性。在基础部分，我们学习了类和对象的定义、属性和方法的使用，以及构造函数和析构函数的作用。在高级部分，我们深入探讨了类的特殊方法、静态方法和类方法，以及抽象基类和多重继承等概念。掌握这些知识，将有助于我们编写更加高效、灵活和可维护的代码。