python面向对象三大特性

面向对象

面向对象编程，是许多编程语言都支持的一种编程思想。

基于模板(类)去创建实体(对象)，使用对象去完成功能开发

面向对象的三大特性

• 封装
• 继承
• 多态

封装

封装表示：将现实世界事物的属性和行为，封装到类中，描述成为成员变量和成员方法

私有成员

既然现实事物有不公开的属性和方法，那么作为现实事物在程序中映射的类，也应该支持

类中提供了私有成员的形式来支持

• 私有成员变量
• 私有成员方法

定义私有成员的方式

• 私有成员变量：变量名以__开头(两个下划线)
• 私有成员方法：方法名以__开头(两个下划线)

使用私有成员

class Phone:
    IMEI = None  # 序列号
    producer = None  # 厂商

    __current_voltage = None  # 当前电压

    def call_by_5g(self):
        print("5G通话已经开通")

    def __keep_single_core(self):
        print("让cpu以单核模式运行")


phone = Phone()  # 创建对象
phone.__keep_single_core()  # 使用私有方法

私有方法无法被对象直接使用

使用私有变量

class Phone:
    IMEI = None  # 序列号
    producer = None  # 厂商

    __current_voltage = 30  # 当前电压

    def call_by_5g(self):
        print("5G通话已经开通")

    def __keep_single_core(self):
        print("让cpu以单核模式运行")


phone = Phone()  # 创建对象
print(phone.__current_voltage)

私有变量无法直接使用

私有成员的意义

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

继承

继承分为：单继承和多继承

继承表示：将从父类那里继承(复制)来成员变量和成员方法（不含私有成员）

单继承

class Phone:
    IMEI = None  # 序列号
    producer = "HW"  # 厂商

    def call_by_4g(self):
        print("4g通话")


class Phone2024(Phone):
    face_id = "10001"  # 面部识别id

    def call_by_5g(self):
        print("2024新功能:5g通话")


phone = Phone2024()
print(phone.producer)  # 子类调用父类的属性
phone.call_by_5g()

多继承

python支持多继承，一个类可以继承多个父类

class 类名(父类1，父类2，父类3...):
    内容体

class Phone:
    IMEI = None  # 序列号
    producer = "HW"  # 厂商

    def call_by_5g(self):
        print("5g通话")


class NFCReader:
    nfc_type = "第六代"
    producer = "XM"

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

    def write_card(self):
        print("写入nfc卡")


class RemoteController:
    rc_type = "红外遥控"

    def controller(self):
        print("红外遥控开启")


class MyPhone(Phone, NFCReader, RemoteController):
    pass


phone = MyPhone()
phone.call_by_5g()
phone.read_card()
phone.write_card()
phone.controller()
print(phone.producer)

多继承的注意事项

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

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

比如上面的案例中的Phone和NFCReader类中都有producer成员属性

然后继承的时候先继承Phone,所以print(phone.producer)打印的时候打印出的是Phone中的producer的值

pass关键字

pass是占位语句，保证函数、方法、类的完整性，表示无内容，空的意思

重写和使用父类成员

重写

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

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

class Animal:
    name = "动物"

    def call(self):
        print("动物会叫")

class Cat(Animal):
    name = "小花猫"

    def call(self):
        print("小花猫喵喵叫")


cat = Cat()
print(cat.name)
cat.call()

Cat类重写的了父类Animal中的属性和方法

使用父类成员

第一种方式：

调用父类成员

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

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

class Animal:
    name = "动物"

    def call(self):
        print("动物会叫")

class Cat(Animal):
    name = "小花猫"

    def call(self):
        print(Animal.name)
        Animal.call(self)
        print("小花猫喵喵叫")


cat = Cat()
cat.call()

第二种方式：

使用super()调用父类成员

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

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

class Animal:
    name = "动物"

    def call(self):
        print("动物会叫")

class Cat(Animal):
    name = "小花猫"

    def call(self):
        print(super().name)
        super().call()
        print("小花猫喵喵叫")


cat = Cat()
cat.call()

注意：只可以在子类内部调用父类的同名成员，子类的实体类对象调用默认是调用子类重写

多态

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

class Animal:
    def spake(self):
        pass


class Dog(Animal):
    def spake(self):
        print("汪汪汪")


class Cat(Animal):
    def spake(self):
        print("喵喵喵")


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


dog = Dog()
cat = Cat()
make_noise(dog)
make_noise(cat)

多态经常作用在继承关系上

比如：

• 函数（方法）形参声明接收父类对象
• 实际传入父类的子类对象进行工作

即：

• 以父类做定义声明
• 以子类做实际工作
• 用以获得同一行为，不同状态

抽象类（接口）

父类的Animal的spake方法，是空实现

这种设计的含义是：

• 父类用来确定有哪些方法
• 具体的方法实现，由子类决定

这种写法就叫做抽象类（也可以称之为接口）

抽象类：含有抽象方法的类

抽象方法：方法体是空实现的（pass）称之为抽象方法

为什么要使用抽象类

提出标准后

不同的厂家各自实现标准的要求

抽象类就好比定义一个标准

包含了一些抽象的方法，要求子类必须实现

配合多态，完成：

• 抽象的父类设计（设计标准）
• 具体的子类实现（实现标准）

class AC:
    def cool_wind(self):
        """制冷"""
        pass

    def hot_wind(self):
        """制热"""
        pass

    def swing_l_r(self):
        """左右摆风"""
        pass


class Midea_AC(AC):
    def cool_wind(self):
        print("美的空调制冷")

    def hot_wind(self):
        print("美的空调制热")

    def swing_l_r(self):
        print("美的空调左右摆风")


class GREE_AC(AC):
    def cool_wind(self):
        print("格力空调制冷")

    def hot_wind(self):
        print("格力空调制热")

    def swing_l_r(self):
        print("格力空调左右摆风")


def make_cool(ac: AC):
    ac.cool_wind()


def make_hot(ac: AC):
    ac.hot_wind()


def make_swing(ac: AC):
    ac.swing_l_r()


midea_ac = Midea_AC()
gree_ac = GREE_AC()

make_cool(midea_ac)
make_cool(gree_ac)

抽象类的作用：多用于顶层设计（设计标准），以便子类做具体实现

也是对子类的一种软性约束，要求子类必须重写（实现）父类的一些方法