【零基础学Python】小白必看：快速理解什么是面向对象编程

面向对象编程（OOP）是编程的一种范式，它使用“对象”来组织代码。那么：

1. 什么是对象？

• 对象是现实世界中的事物的抽象。例如，"狗"、"车"、"学生"都是对象。每个对象都有属性和行为。
• 属性是对象的特征，比如一只狗的颜色、品种等。
• 行为是对象可以执行的动作，比如一只狗可以“跑”、“叫”等。

2. 类

• 类是创建对象的蓝图或模板。你可以把类想象成一个设计图。
• 使用类可以创建多个对象，所有这些对象都有相同的属性和行为。

3. 创建类和对象

在Python中，可以使用class关键字来定义一个类。例如：

# 定义一个类
class Dog:
    # 初始化方法，创建对象时会被调用
    def __init__(self, name, breed):
        self.name = name  # 对象的属性
        self.breed = breed  # 对象的属性

    # 对象的行为
    def bark(self):
        print(f"{self.name} says: Woof!")

# 创建对象
my_dog = Dog("Buddy", "Golden Retriever")

# 访问对象的属性
print(my_dog.name)  # 输出: Buddy
print(my_dog.breed)  # 输出: Golden Retriever

# 调用对象的方法
my_dog.bark()  # 输出: Buddy says: Woof!

4. 继承

继承是OOP的一个重要特性，它允许我们创建一个新类，该类可以继承已有类的属性和方法。

# 定义一个父类
class Animal:
    def speak(self):
        print("Animal speaks")

# 定义一个子类，继承自Animal
class Cat(Animal):
    def speak(self):
        print("Meow!")

# 创建对象
my_cat = Cat()
my_cat.speak()  # 输出: Meow!

5. 封装

在 Python 中，封装是面向对象编程（OOP）中的一个重要概念。它主要指的是将数据（属性）和操作数据的方法（函数）封装在一起，形成一个对象。通过封装，我们可以更好地管理和保护数据，避免外部直接访问和修改。

封装的几个关键点：

1. 数据隐藏：

   • 封装允许我们隐藏对象的内部状态，只通过公开的方法来访问或修改这些状态。这意味着我们可以控制对数据的访问，防止不正确的操作。

2. 使用类：

   • 在 Python 中，我们使用类（class）来实现封装。类是一个蓝图，可以创建对象（实例）。对象包含属性（数据）和方法（操作）。

3. 访问修饰符：

   • Python 中没有严格的访问修饰符，但我们可以使用下划线约定来表示属性的可访问性。
     • 单下划线（_）表示“保护”属性，表示这个属性是内部使用的，不应该在类外部直接访问。
     • 双下划线（__）表示“私有”属性，Python 会对其进行名称重整，进一步保护属性不被直接访问。

class BankAccount:
    # 定义了一个名为 BankAccount 的类，用于模拟银行账户

    def __init__(self, balance=0):
        # 初始化方法，创建对象时调用
        # balance 参数默认值为 0
        self.__balance = balance  # 私有属性，用于存储账户余额

    def deposit(self, amount):
        # 存款方法，接受一个参数 amount，表示存款金额
        if amount > 0:
            # 检查存款金额是否大于 0
            self.__balance += amount  # 将存款金额加到余额上
            print(f"存款成功！当前余额: {self.__balance}")  # 输出存款成功的信息和当前余额
        else:
            # 如果存款金额不合法
            print("存款金额必须大于0!")  # 输出错误信息

    def withdraw(self, amount):
        # 取款方法，接受一个参数 amount，表示取款金额
        if 0 < amount <= self.__balance:
            # 检查取款金额是否大于 0 且小于等于当前余额
            self.__balance -= amount  # 从余额中扣除取款金额
            print(f"取款成功！当前余额: {self.__balance}")  # 输出取款成功的信息和当前余额
        else:
            # 如果取款金额不合法或余额不足
            print("取款金额不合法或余额不足!")  # 输出错误信息

    def get_balance(self):
        # 获取余额的方法
        return self.__balance  # 返回当前余额，允许外部访问私有属性

# 使用 BankAccount 类
account = BankAccount()  # 创建一个 BankAccount 对象，余额默认为 0
account.deposit(100)  # 存入 100 元
account.withdraw(50)  # 取出 50 元
print("最终余额:", account.get_balance())  # 输出最终余额

6. 多态

多态是一个来自于计算机科学的概念，字面意思是“多种形态”。在编程中，多态指的是同一种操作可以作用于不同类型的对象上，具体的操作会根据对象的类型而有所不同。这使得代码更具灵活性和可扩展性。

在 Python 中的多态

在 Python 中，多态通常与面向对象编程 (OOP) 相关。它允许你使用统一的接口来处理不同类型的对象。你可以通过方法重写来实现多态。

举个例子

假设我们有一个动物类（Animal），然后有两个子类：Dog 和 Cat。我们希望它们都能发出声音，但声音的具体实现是不同的。

# 定义一个基类 Animal
class Animal:
    # 定义一个空的方法 speak，子类需要重写这个方法
    def speak(self):
        pass  # 这是一个空方法，子类会重写这个方法

# 定义一个 Dog 类，继承自 Animal
class Dog(Animal):
    # 重写 speak 方法，返回狗的叫声
    def speak(self):
        return "Woof!"

# 定义一个 Cat 类，继承自 Animal
class Cat(Animal):
    # 重写 speak 方法，返回猫的叫声
    def speak(self):
        return "Meow!"

# 定义一个函数 animal_sound，接受一个 Animal 类型的参数
def animal_sound(animal):
    # 调用传入对象的 speak 方法并打印结果
    print(animal.speak())

# 创建 Dog 类的实例
dog = Dog()
# 创建 Cat 类的实例
cat = Cat()

# 调用函数，传入 dog 对象，输出: Woof!
animal_sound(dog)  # 输出: Woof!
# 调用函数，传入 cat 对象，输出: Meow!
animal_sound(cat)  # 输出: Meow!

1. 基类（Animal）: 这是一个抽象类，定义了一个方法 speak()，这个方法没有具体的实现（使用 pass 关键字）。其目的是让子类必须实现这个方法。

2. 子类（Dog 和 Cat）: 这两个类分别继承自 Animal，并重写了 speak() 方法，提供了各自的实现。

3. 多态（Polymorphism）: animal_sound 函数接受任何 Animal 类型的对象，并调用其 speak() 方法。通过传入不同的对象（dog 和 cat），可以得到不同的结果，这就是多态的体现。

4. 实例化和调用: 创建 Dog 和 Cat 的实例后，调用 animal_sound 函数时，程序根据传入的对象类型，动态决定调用哪个 speak() 方法。