Python基础——面相对象的三大特征【封装，继承，多态】

📝前言：
上一篇文章Python基础——类讲解了python语法中的类，类是面相对象的模版，这篇文章我们就初步讲解面相对象的三大特征：
1，封装
2，继承
3，多态

🎬个人简介：努力学习ing
📋个人专栏：C语言入门基础以及python入门基础
🎀CSDN主页 愚润求学
🌄每日鸡汤：我努力过无数次，但我知道，机会只会出现在其中一两次

---

一，封装

封装指的是：将对象的状态（属性）和行为（方法）包装在一个单一的单元中。这样做的主要目的是为了保护对象的内部状态，并确保外部世界无法随意访问或修改它。同时，封装还可以提供一种方式来控制对对象的访问，从而实现数据的安全性和完整性。

在上篇文章中，我们讲到的方法都是公共方法。公共方法是指：不使用任何特殊前缀的方法。这些方法可以在类的外部被调用，用于提供对外部世界的访问或修改对象状态的途径。

在 Python 中，私有的属性和方法可以用于保护对象内部状态：
私有属性：使用双下划线前缀来定义私有属性，例如：__private_attr。这样的属性在类的外部是不可见的，也不能被外部访问。
私有方法：使用双下划线前缀来定义私有方法，例如 __private_method。这样的方法在类的外部是不可见的，也不能被外部调用。

以下是一个简单的示例，展示了如何在 Python 类中使用封装：

class BankAccount:
    def __init__(self, account_holder, balance=0):
        self.__account_holder = account_holder
        self.__balance = balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return f"Deposited ${amount}. New balance:${self.__balance}"
        else:
            return "Invalid deposit amount."

    def withdraw(self, amount):
        if amount > 0 and amount <= self.__balance:
            self.__balance -= amount
            return f"Withdrew ${amount}. New balance:${self.__balance}"
        else:
            return "Invalid withdrawal amount or insufficient funds."

    def get_balance(self):
        return f"Balance for {self.__account_holder}: ${self.__balance}"

account = BankAccount("Alice", 1000)
print(account.deposit(500))
print(account.withdraw(200))
print(account.get_balance())
# 错误示范：print(account.__account_holder)

在上面的示例中，BankAccount 类有两个私有属性 __account_holder 和 __balance，以及三个公共方法 deposit、withdraw 和 get_balance。通过这种方式，我们可以保护账户持有人的姓名和余额，同时允许外部世界进行存款、取款和查询余额的操作。
输出结果：

二，继承

继承：当一个类继承另一个类时，它会继承另一个类的属性和方法（不含私有）。这使得我们可以创建一个新类，无需从头开始定义，又可以拥有父类的特性。（也就是说，新类是基于父类定义的）
优点：
1，代码重用：通过继承，子类可以重用父类的代码，减少重复代码。
2，增加代码的模块化：继承有助于将代码组织为更小、更相关的模块。
3，提高代码的可维护性：当需要更改基类时，所有继承的子类都会受到影响。

1，单继承

单继承示例（即只继承一个父类）：
假设我们有一个 Vehicle 类，它代表一种交通工具。这个类有一个 drive 方法，用于驾驶交通工具。我们可以定义一个 Car 类，它继承自 Vehicle 类。Car 类将包含更多关于汽车的信息，如 brand 和 model。

class Vehicle:
    def __init__(self, make):
        self.make = make

    def drive(self):
        return "Driving"

class Car(Vehicle):  
    def __init__(self, brand, model):
        super().__init__(brand)  # 我们调用父类的__init__方法，给子类的brand赋初始值
        self.model = model

my_car = Car("Toyota", "Camry")  # 用子类创建对象
# 虽然Car里面没有drive()方法，但是Car继承了Vehicle的特征，所以可以调用父类的方法
print(my_car.drive())  # 输出：Driving

2，多继承

多继承（继承多个父类）：
语法：

calss 子类名(父类1, 父类2,……):
	……

多继承中，如果父类有同名属性或方法，先继承的优先级高于后继承的：

class Vehicle1:
    def drive(self):
        print("driving1")
        
class Vehicle2:
    def drive(self):
        print("driving2")
        
class Car(Vehicle1, Vehicle2):
    def __init__(self,name):
        self.name = name
        
car1 = Car('xiaomi')
car1.drive()  # 输出：driving1

3，复写

子类在继承父类的特征后，可以对特征（即属性和方）进行复写（重写）
例如：
首先，我们定义一个父类 Animal，它有一个方法 speak，接下来，我们定义一个子类 Dog，它继承自 Animal，并复写父类的方法 speak：

class Animal:
    def speak(self):
        return "Some sound"

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

# 创建Dog示例，并调用speak方法：
dog = Dog()
print(dog.speak())  # 输出: Woof!
# 可见speak的返回内容被修改了

一旦复写完父类的特征，那么调用类的成员的时候，就会调用新成员
如果需要使用被复写的父类成员，需要使用特殊方法：
（因为如果在子类内调用父类的同名成员，默认是调用子类复写的）

# 第一种
父类名.成员变量
父类名.成员方法(slef)
# 第二钟（相当于用super()找到了父类）
super().成员变量
super().成员方法(self)

例如：

class Animal:
    def speak(self):
        return "Some sound"

class Dog(Animal):
    # 复写了父类的方法：
    def speak(self):
        return "Woof!"

    # 调用父类原来的speak方法：
    # 默认调用的是子类复写以后的：
    def speak2(self):
        return self.speak()
    def speak3(self):
        return Animal.speak(self)  # 或者return super().speak(self)

# 创建Dog示例，并调用speak2方法：
dog = Dog()
print(dog.speak2())  # 输出：Woof（可见默认调用的是子类复写后的）
print(dog.speak3())  # 输出：Some sound

三，多态

多态是面向对象编程中的一个核心概念，它允许我们使用统一的接口来定义多种不同的实现方式。多态的主要特点是基于对象的类型进行函数的调用，而这个过程是动态绑定的，即在运行时而非编译时确定调用哪个函数。

在Python中，由于其动态类型的特性，多态是天然存在的。这里我们可以从两个方面来讨论Python中的多态：
1，动态类型：Python是一种动态类型语言，这意味着我们不需要在声明变量时指定其类型。这使得函数可以接受任何类型的参数，只要该参数支持函数期望的操作或方法。
2，方法重写：子类可以提供父类方法的特定实现（即复写）。当子类对象调用该方法时，会调用子类中的实现，而不是父类中的实现。

下面是一个简单的例子来说明Python中的多态：

class Animal:
    def sound(self):
        pass  # pass是占位语句，用来保证代码的完整性

class Dog(Animal):
    def sound(self):
        return "Woof!"

class Cat(Animal):
    def sound(self):
        return "Meow!"

def animal_sound(animal):
    return animal.sound()

d = Dog()
c = Cat()

print(animal_sound(d))  # Woof!
print(animal_sound(c))  # Meow!

在上述代码中，我们定义了一个Animal类，它有一个sound方法。Dog和Cat子类分别重写了sound方法，提供了它们自己的实现。
animal_sound函数接受一个Animal类型的参数，并调用其sound方法。由于多态，这个函数可以接受任何实现了sound方法的对象作为参数。
（Animal类型指的是 Animal 类所表示的类型，即在这个例子中，它是一个抽象基类）

总之，多态允许我们编写更加通用和可扩展的代码，而不需要关心具体的对象类型。
在此，我推荐一篇写的也很好的讲解多态的文章：Python | 多态（如有侵权，请告知）

---

🌈我的分享也就到此结束啦🌈
要是我的分享也能对你的学习起到帮助，那简直是太酷啦！
若有不足，还请大家多多指正，我们一起学习交流！
📢公主，王子：点赞👍→收藏⭐→关注🔍
感谢大家的观看和支持！祝大家都能得偿所愿，天天开心！！！