Python 面向对象编程 (OOP)

面向对象编程（Object-Oriented Programming, OOP）是一种强大的编程范式，它使用“对象”来设计软件。对象将数据（属性）和操作数据的函数（方法）捆绑在一起。Python 从一开始就是一门面向对象的语言。

类 (Class) 和对象 (Object)

• 类 (Class): 是创建对象的蓝图或模板。它定义了对象将拥有的属性和方法。
• 对象 (Object): 是类的实例。你可以根据一个类创建出许多个对象，每个对象都拥有类定义的属性和方法，但可以有自己独立的数据。

把类想象成一个“汽车”的设计图，而对象就是根据这张图纸制造出来的每一辆具体的汽车（如你的车、我的车）。

定义一个类

使用 class 关键字来定义一个类。

class Dog:
    """一个表示小狗的简单类。"""

    # __init__ 方法是一个特殊的方法，用于初始化对象
    # 当你创建一个新的 Dog 实例时，Python 会自动调用它
    def __init__(self, name, age):
        """初始化 name 和 age 属性。"""
        self.name = name  # 属性
        self.age = age    # 属性

    # 方法
    def sit(self):
        """模拟小狗坐下。"""
        print(f"{self.name} is now sitting.")

    def roll_over(self):
        """模拟小狗打滚。"""
        print(f"{self.name} rolled over!")

self 参数

你可能注意到了所有方法中的第一个参数 self。它是一个指向实例本身的引用，让实例能够访问其自身的属性和方法。在调用方法时，你不需要为 self 传递参数，Python 会自动完成。

创建和使用对象

创建类的实例（即实例化）就像调用函数一样。

# 根据 Dog 类创建一个名为 my_dog 的实例
my_dog = Dog("Willie", 6)

# 访问属性
print(f"My dog's name is {my_dog.name}.")
print(f"My dog is {my_dog.age} years old.")

# 调用方法
my_dog.sit()
my_dog.roll_over()

继承 (Inheritance)

继承是 OOP 的一个核心概念，它允许我们创建一个新类（子类），这个新类会继承一个已存在的类（父类）的所有属性和方法。子类可以重写父类的方法，也可以添加自己的新方法。

这实现了代码的重用。

# 创建一个父类
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("Some generic animal sound")

# 创建一个子类 Cat，它继承自 Animal
class Cat(Animal):
    def __init__(self, name, color):
        # super() 函数用于调用父类的方法
        super().__init__(name) # 调用父类的 __init__ 方法
        self.color = color

    # 重写父类的 speak 方法
    def speak(self):
        print("Meow!")

    # 添加自己的新方法
    def purr(self):
        print(f"{self.name} is purring.")

# 创建实例
my_cat = Cat("Mitty", "white")
my_cat.speak() # 调用的是 Cat 类中重写的方法 -> Meow!
my_cat.purr()  # 调用 Cat 类自己的方法 -> Mitty is purring.

封装 (Encapsulation)

封装是指将数据（属性）和操作数据的代码（方法）捆绑在一个单元（类）中。在 Python 中，我们通常通过命名约定来表示属性的可见性：

• name: 公有属性，可以在类的外部自由访问。
• _name: “受保护”的属性，按照约定，它只应该在类及其子类内部使用。
• __name: “私有”属性，Python 会对其进行名称改写（name mangling），使得在外部很难直接访问，从而实现更强的封装。

封装有助于隐藏对象的内部状态，只暴露必要的接口，从而提高代码的安全性和可维护性。