Python 面向对象三大特性

        Python 的面向对象三大特性使得它成为了一种非常强大的编程语言，并且在各种应用场景中得到了广泛的应用。接下来就细致的分析一下：

类的定义与使用

class Car(object): # 定义一个类，派生自object类
    def show_info(self): # 定义成员方法
        print('This is a car')
car = Car() # 类的实例化（对象）
car.show_info() #调用对象的方法成员

数据成员和成员方法

        数据成员(attribute)：创建类时用变量的形式来表示对象特征的成员

        成员方法(methods)：用函数的形式表示对象行为的成员

公有成员

        公有成员：可以公开使用的，既可以在类的内部使用，也可以在外部程序中调用。

私有成员

        私有成员：在类的外部不能直接访问，一般是在类的内部进行访问和操作，或者在类的外部通过调用对象的公有成员方法来访问。

     分类：

                私有成员变量：变量名以__开头（注意：这里的下划线是2个）

                私有成员方法：方法名以__开头（注意：这里的下划线是2个）

      意义：

                在类中提供仅供内部使用的属性和方法，而不对外开放(类对象无法使用)

封装

        封装是面向对象编程的核心思想之一，它将对象的属性和方法封装在一起，形成一个独立的单元。通过封装，可以隐藏对象的内部实现细节，提高代码的可维护性和可重用性。

定义一个类，内部含有成员变量和私有成员方法

class Phone:
    __current_voltage = 1  #封装一个方法，代表当前手机的运行电压（私有的成员变量）

    def __keep_single_core(self):  # （私有的成员方法）
        print("单核模式")

    def call_by_5g(self):  # 公共的方法，可以被调用
        if self.__current_voltage >= 1:
            print('5g开启')
        else:
            self.__keep_single_core()
            print("电量不足")

phone = Phone()
phone.call_by_5g()
phone.__keep_single_core()  # 这里会报错，因为被封装了是私有的
print(phone.__current_voltage)   # 这里也会报错，因为是私有的

                类对象无法访问私有成员，但是类中的其他方法还是可以访问私有成员

        自己可以把当前代码的__current_voltage的值修改为0.1试一下会输出什么？

---

继承

        继承是面向对象编程中的另一个重要特性，它允许一个类继承另一个类的属性和方法。通过继承，可以实现代码的复用，减少代码的冗余。

  定义：

继承就是一个类，继承另外一个类的成员变量和成员方法

  语法：

class 类(父类 [父类1,父类2,...])

        类的内容体

  单继承

class phone:
    IMEI = None
    producer = 'ZZZ'

    def call_by_4g(self):
        print('4g')

class Phone666(phone):  # 这里继承了phone类，代码phone类就是Phone666的父类
    face_id = '123123'

    def call_by_5g(self):
        print('新的 5g')

A = Phone666()
print(A.IMEI, A.producer, A.face_id)
A.call_by_5g()
A.call_by_4g()

  多继承

class NFC:
    nfc_type = '第五代'
    producer = 'AAA'

    def read_card(self):
        print("NFC读卡器")

    def write_card(self):
        print("NFC写卡")


class RemoteControl:
    rc_type = '红外遥控'

    def control(self):
        print('开启红外')


class MyPhone(NFC, RemoteControl):
    pass  # 用来补全语法，不想添加新的功能


B = MyPhone()
B.control()
print(B.nfc_type)

  注意

多个父类当中，如果有同名的成员，那么默认以继承的顺序（从左到右）为优先级

即：先继承的保留，后继承的被覆盖

 复写

        定义：

子类继承父类的成员属性和成员方法之后，如果对其不满意的话，那么可以就进行复写

即：子类中重新定义的同名的属性和方法

class Phone:
    IMEI = None
    producer = 'ZZZ'

    def call_by_4g(self):
        print('4g')

class Phone2(Phone):
    producer = 'XXX'  # 对父类里面的producer进行了修改

    def call_by_4g(self):  # 对父类里面的方法的属性进行复写
        print('新的')

p = Phone2()
p.call_by_4g()
print(p.producer)

当子类已经复写了父类中的成员属性和成员方法之后，你还想用到父类中的方法该怎么办呢？

所以这时候就需要调用父类中的成员了

调用父类的同名成员

  方法1：调用父类的成员

        使用成员变量：父类名.成员变量

        使用成员方法：父类名.成员方法(self)

  方法2：使用super()调用父类成员

        使用成员变量：super().成员变量

        使用成员方法：super().成员方法()

---

多态

        多态是面向对象编程中的第三个重要特性，它允许不同的类对象对同一消息做出不同的响应。通过多态，可以提高代码的灵活性和扩展性。

  定义：

        指的是多种状态下，即完成某个行为的时候，使用不同的对象会得到不同的状态

class Animal:
    def speak(self):
        pass

class Dog:
    def speak(self):
        print("DDD")

class Cat:
    def speak(self):
        print("CCC")

def make_noise(animal: Animal):
    animal.speak()

dog = Dog()
cat = Cat()

make_noise(dog)
make_noise(cat)