Python入门-面相对象——class(类)、封装、继承、多态、类型注解

面向对象

面向对象就是设计一个类，基于类创建对象，并使用创建出来的类完成具体的工作

面向对象的三大特性：封装、继承、多态

面向对象基本概述:
    属性: 名词, 用来描述事物的外在特征的, 例如: 姓名, 性别, 年龄, 身高, 体重...
    行为: 动词, 表示事物能够做什么, 例如: 学习, 吃, 睡...
    类: 抽象的概念, 看不见, 摸不着.  类 = 属性 + 行为
    对象: 类的具体体现, 实现.

定义类的格式:
    class 类名:
        # 属性, 就和以前定义变量一样.
        # 行为, 就和以前定义函数一样, 只不过第一个形参要写self

如何使用类中的成员:
    1. 创建该类的对象.
        对象名 = 类名()
    2. 通过 对象名. 的方式来调用.
        对象名.属性
        对象名.行为()

1. class(类)

初识对象

使用对象组织数据：先 创建类(class)，类名加括号便是创建对象，最后对象属性赋值

# 设计一个类（类比生活，登记表）
class PersonTable:
    name = None

# 设计对象（打印登记表）
t1 = PersonTable()

# 对象属性进行赋值
t1.name = 'bob'

# 获取对象中记录的信息
print(t1.name)

类的成员

class是关键字，表示要定义类了
类的属性(数据)，即定义在类中的变量(成员变量)
类的行为(函数)，即定义在类中的函数(成员方法)

定义在类外面的函数叫做函数，类内部的函数叫做方法

# 成员方法的定义语法
def 方法名(self, 形参1, ..., 形参N):
    方法体

方法定义中 self 必须填写，用来表示类对象自身的意思，谁调用self, self就是谁。
当我们使用类对象调用方法时，self会自动被python传入，在方法内部想要访问类的成员变量，必须使用 self

类和对象

类只是一种程序内的 ’设计图纸‘ ，需要基于图纸生产实体（对象），才能正常工作，称为：面向对象编程

魔法方法

魔法方法在创建类对象（构造类）的时候：
（1） 会自动执行
（2）将传入参数自动传递给构造方法使用

其他内置方法(魔术方法)

_ _init__是python类内置的方法之一，内置的类方法，各有各自特殊的方法，这些内置方法称之为：魔术方法

常用的魔法方法:
    __init__()  在创建对象的时候, 会被自动调用, 一般用于给对象初始化一些属性值.     即:  对象名 = 类名()  就会自动调用该魔法方法.
    __str__()   当输出语句直接打印对象的时候, 会自动调用该魔法方法, 默认打印的是地址值, 无意义, 一般会改为: 打印该对象的各个属性值.
    __del__()   当手动删除对象时 或者 文件执行结束后, 该函数会被自动调用.

可以理解为:
    init魔法方法:       创建1个对象 = 调用一次
    str魔法方法:        打印一次对象 = 调用一次
    del魔法方法:        只要删除1个该类的对象 = 调用一次


# 小于、大于符号比较
__lt__

# 小于等于、大于等于符号比较
__le__

# ==符号比较
__eq__

2. 封装

封装的概念：将现实世界事物在类中描述为 属性和方法，即为封装

类中的部分属性和行为不对外公开，称为私有成员，类对象无法访问私有成员，但类中的其他成员可以访问私有成员

封装介绍:
    概述:
        封装指的是 隐藏对象的属性 和 实现细节, 仅对外提供公共的访问方式.
    问1: 怎么隐藏 对象的属性 和 实现细节(函数)?
    答: 通过 私有化解决.

    问2: 公共的访问方式是什么?
    答: get_xxx(), set_xxx()函数.

    问3: get_xxx()和set_xxx()函数 必须成对出现吗?
    答: 不一定, 看需求, 如果只获取值就用 get_xxx(), 如果只设置值就用 set_xxx(). 如果需求不明确, 建议都写.

    问4: 封装指的就是 私有, 这句话对吗?
    答: 不对, 因为我们常用的函数也是封装的一种体现.

    好处:
        1. 提高代码的安全性.        通过 私有化 实现的.
        2. 提高代码的复用性.        通过 函数 实现的.
    弊端:
        代码量增量了, 封装的代码量会变多.
        这里的代码量增加指的是:  私有化以后, 就要提供公共的访问方式, 私有化内容越多, 公共的访问方式就越多, 代码量就越多.

私有化介绍:
    格式:
        __属性名       # 注意: 这里是 两个_
        __函数名()
    特点:
        只能在本类中直接访问, 外界无法直接调用.
        
私有化方法.   即: 父类的私有化方法, 也需要提供1个公共的访问方式, 让子类来访问.

问: 什么时候使用私有化呢?
答: 父类的成员不想被子类直接继承(或者重写, 修改等), 但是还想给子类用, 就可以考虑用私有化.

以下是一个简单的案例

# 1. 定义徒弟类, 有自己的属性 和 行为.
class Prentice(object):
    # 1.1 属性
    def __init__(self):
        self.kongfu = '[独创的煎饼果子配方]'
        # 私有的属性.
        # self.__money__ = 500000     # 这个不是私有, 就是变量名叫: __money__
        self.__money = 500000         # 这个才是私有化的写法.

    # 1.2 对外提供公共的访问方式, 可以实现: 获取私有的变量, 以及给变量设置值.
    # 获取值.
    def get_money(self):
        return self.__money

    # 设置值
    def set_money(self, money):
        self.__money = money

    # 1.3 行为
    def __make_cake(self):
        print(f'采用 {
     
     self.kongfu} 制作煎饼果子!')
        # 验证: 私有成员, 在本类中是可以直接访问的.
        print(f'私房钱为: {
     
     self.__money}')

    # 针对于父类的私有方法, 提供公共的访问方式(在其内部调用 私有化的方法即可)
    def my_make(self):
        # 调用私有化方法 __make_cake()
        self.__make_cake()

# 2. 定义徒孙类, 继承自徒弟类.
class TuSun(Prentice):
    # 演示用, 在子类中 恶意的修改 父类的函数内容. 通过 方法重写 实现.
    # def make_cake(self):
    #     print('加