Python 面向对象编程

基本概念

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

简答理解就是，基于类去创建对象，使用对象完成功能开发。

目前通用的编程方式分为两种：面向过程编程 和面向对象编程。 简单介绍一下两种编程方式：

面向过程

做法

1. 把完成某个需求的所有步骤从头到尾的实现
2. 根据开发需求，将某些独立的代码封装成一个又一个的函数
3. 最后完成的代码，就是顺序的调用不同的函数

特点

1. 注重步骤和过程，不注重职责和分工
2. 如果需求复杂，代码也会变得复杂
3. 开发复杂的项目，没有固定的套路，开发难度大

面向对象

做法

1. 开发需求前，首先确定职责 ---- 要做的事情
2. 根据职责 确定不同的对象，在对象内部封装不同的方法
3. 最后完成的代码，就是顺序的让不同的对象调用不同的方法

相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法

特点

1. 注重 对象和职责， 不同的对象承担不同的职责
2. 更加适合应对复杂的需求变化，是专门应对复杂的项目开发，提供的固定套路

简而言之，就是程序中所有的操作，都是通过对象来完成的。计算机程序本质是对现实事物的抽象。一个人，一辆车，一只狗，这些都是对象，而这些对象发出的动作就是对象的方法，某些特征就是对象的属性。比如一个人，他的身高，长相，姓名，年龄等这些在对象中都是他的属性，而他发出的动作，走，跑，说话等这些在对象中都是他的方法。

面向对象的核心概念

类 和 对象是面向对象编程的两个核心概念。

类是对一群具有相同特征或行为的事物的一个统称，是抽象的，不能直接使用，特征类的属性，行为是类的函数方法。

对象 是由类创造出来的一个具体的存在，可以直接使用。由哪一个类创造出来的对象 ，就拥有哪一个类中定义的属性和方法。

Python 程序开发中，设计一个类的三要素：

1. 类名 这类事物的名字，满足大驼峰命名法（EventBus）
2. 属性 这类事物具有的特征
3. 方法 这类事物具有的行为

基本语法

创建一个简单的类

class 类名:
    def 方法1(self, 参数列表):
        pass
        
    def 方法2(self, 参数列表):
        pass

对象变量 = 类名()

Python 定义类的方法时，第一个参数必须是 self。调用方法时，不需要传递self

self 哪一个对象调用的方法，self就是哪一个对象的引用。

在方法内部可以通过self.访问对象的属性，也可以通过self.调用对象的其它方法。

构造方法

Python中通过__init__构造方法对成员变量进行赋值。

特点

1. 创建类对象的时候，会自动执行；
2. 创建类对象的时候，将传入参数自动传递给__init__方法使用。

基本使用

class Person:
    # 初始化方法，自动调用
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 自定义方法
    def show(self):
        print(f'我的名字叫{self.name}，今年{self.age}岁')

使用类创建对象，通过：

person1 = Person('小明', 18)
person1.show() # 我的名字叫小明，今年18岁

person2 = Person('小红', 17)
person2.show() # 我的名字叫小红，今年17岁

在这个类中，定义的__init__ 方法，表示初始化使用方法，在对象初始化的过程中，会直接调用，跟其他语言中的 constructor初始化函数功能是相同的。

我们通过实例化的两个对象person1和person2，是通过同一个类创建的，但是内存地址不同。每次创建的都是一个新的对象，开辟新的内存空间存储。

类对象的生命周期

• 一个对象从调用类名()创建，生命周期开始，会为对象分配内存空间，自动调用__init__方法；
• 一个对象的__del__方法一旦被调用生命周期就结束，也就对象在内存中被销毁了，对象销毁前会自动调用__del__方法；
• 在对象的生命生命周期内，可以访问对象的属性或者方法，一旦对象销毁，就不能在调用。

__str__ 也是类中，自动会执行的方法，我们在打印对象的时候，可以通过__str__方法控制打印输出的返回值。

面向对象的三大特征

封装

封装是指隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别。在Python中，这通常是通过将属性设置为私有（使用双下划线前缀）来实现的，而公开的方法则作为接口供外部调用。封装可以提高代码的安全性，防止外部代码随意访问和修改对象的内部状态。

简答描述就是将现实世界事物的 属性和方法 ，封装到类中，表示为 成员变量和成员方法 ，从而完成程序对现实世界事物的描述。

私有成员

现实世界中事物有不公开的行为，比如在手机这个事物中，颜色、尺寸、拍照、上网都是公开给用户的，但是，比如像内存调度，CPU，系统等是不公开的，那么对于程序中的映射也是支持私有属性及方法的。

Python中定义私有成员变量及方法，只需要在变量和方法前面加上__双下划线。比如：__cpu、

__schedule_memory

在Python中使用私有的成员属性和方法时，在类内部使用可以正常访问，创建的类对象使用会报错。

基本使用

class Phone:
    __voltage = 220

    def __schedule_memory(self):
        print('内存调度')

    def call(self):
        if(self.__voltage > 1):
            print('通话')
        else:
            print('电压不足，无法通话')

phone = Phone()
phone.__schedule_memory() # 报错
phone.call()

内部变量__voltage，可以在内部call方法中使用。

私有成员变量使用的意义在于，在类中提供仅供内部使用的属性和方法，而不对外开放（类对象无法使用）。

继承

继承是从已有的类创建新类的过程。在Python中，通过class关键字定义新类，并使用括号将父类名放在新类名的后面，就可以实现继承。子类可以继承父类的所有属性和方法，并可以添加或覆盖自己的属性和方法。继承可以重用代码，提高代码的可维护性和可扩展性。

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

基本使用

单继承

class ApplePhone:
    def __init__(self):
        self.color = 'black'
        self.dpr = 2

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

class ApplePhone2022(ApplePhone):
    def __init__(self):
        super().__init__()
        self.face_id = True

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

apple_phone = ApplePhone2022()
print(apple_phone.color)
apple_phone.call_by_4g()

多继承

class ApplePhone:
    def __init__(self):
        self.color = 'black'
        self.dpr = 2

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

class NFCReader:
    def nfc_read(self):
        print('nfc读卡')

class ApplePhone2022(ApplePhone, NFCReader):
    def __init__(self):
        super().__init__()
        self.face_id = True

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

apple_phone = ApplePhone2022()
apple_phone.nfc_read()

ApplePhone2022类在继承多个类的时候，仅需要将ApplePhone, NFCReader通过逗号隔开类名。如果继承的多个类，有重名的属性或方法，谁先继承，谁的优先级更高。

属性方法重写

class ApplePhone:
    def __init__(self):
        self.color = 'black'
        self.dpr = 2

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

class ApplePhone2022(ApplePhone):
    def __init__(self):
        super().__init__()
        self.color = 'white'
        self.face_id = True

    def call_by_4g(self):
        # 如果还需要父类的方法
        super().call_by_4g()
        print('4g通话---重写')

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

apple_phone = ApplePhone2022()
print(apple_phone.color) # white
apple_phone.call_by_4g() # 4g通话---重写

属性和方法的重写，只需要在继承的子类中，定义重名的属性或方法就可实现重写。如果还需要父类中的方法，通过super().call_by_4g()去调用。

多态

多态是指允许不同类的对象对同一消息作出响应。在Python中，多态通常是通过方法的重写（Overriding）和方法的重载（Overloading）来实现的。重写是指子类可以覆盖父类的方法，使得当子类对象调用该方法时，执行的是子类的方法。重载是指同一个方法名可以对应多个不同的实现，根据参数的类型和数量来确定调用哪个实现。多态可以提高代码的灵活性和可扩展性

多态表示：多种状态，即完成某个行为时，使用不用的对象会得到不同的状态。

即同样的行为，使用不同的对象，获得不同的运行状态。

多态常用在继承关系上，比如

• 函数形参声明接收父类对象
• 实际传入父类的子类对象进行工作，获得同一行为的不同状态。

抽象类

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

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

设计含义：

1. 父类确定有哪些方法
2. 具体的实现方法，由子类决定

这种写法被称为抽象类（接口），一般用来做顶层设计。子类用来实现功能。

基本使用

#  抽象类，用来做顶层设计
class Animal():
    # 抽象方法，空实现
    def speak(self`):`
        pass

class Dog(Animal):
    def speak(self):
        print('汪汪汪')

class Cat(Animal):
    def speak(self):
        print('喵喵喵')

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

dog = Dog()
cat = Cat()
speak(dog)
speak(cat)