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

封装

封装就是使用特殊的语法，对成员属性和成员方法进行包装，达到保护和隐藏的目的
但是一定注意，不能把成员全部封装死，就失去意义了
被封装的成员主要是供类的内部使用
被特殊语法封装的成员，会有不同的访问的权限

封装的级别

封装的级别
    成员   ==> 公有的
    _成员  ==> 受保护的 （约定俗成，而python没有具体实现）
    __成员 ==> 私有的
          公有的 public    受保护的 protected     私有的 private
在类的内部      OK              OK                 OK
在类的外部      OK              No(python可以)      No

封装的实现

公有的封装：
    定义：默认定义的成员都属于公有成员
    特征：公有的成员可以在任何位置进行访问和操作
受保护封装
        定义：在成员名称前面加一个下划线 _成员名称
        特征：受保护的成员和公有成员一样可以在任何位置进行访问，但是一般不要随便访问和操作受保护成员
私有的封装
        定义：在成员名称前面加两个下划线 __成员名称
        特征：私有的成员只能在当前类的内部去访问和操作，不能在类的外部进行操作

查看对象的成员

# 查看对象的所以成员
print(ym.__dict__)  # 可以获取当前对象的所有成员信息
# print(Person.__dict__) # 可以获取当前类的所有成员信息
#{'name': '杨幂', '_age': 28, '_Person__sanwei': '60 55 60'}

了解：

1. 在python中并没有实现受保护的封装，属于开发者的约定俗成。
2. python中的私有化封装是通过改名策略实现的，并不是真正的私有化

继承

什么是继承？

文化的传承，技艺的传承，衣钵的继承。。。

计算机中的继承

在面向对象中，一个类去继承父类，那么这个类就拥有了父类中的所有成员（除了私有成员）

概念：

• 被其它类继承的类，这个类称为 父类 也叫做 基类 或者 超类

• 继承其它类的类，这个类称为 子类，也叫做 派生类

继承的意义：

提高代码的重用性，建立新的类与类的关系，方便其它逻辑的操作

继承语法格式

class 父类():
    pass
class 子类(父类):
    pass

继承的特征

• 在不指定继承的父类时，所有类都继承自object类（系统提供） 了解
• 子类继承了父类后，就拥有了父类中的所有成员包括魔术方法（除了私有成员）
• 子类继承父类后，并不会把父类的成员复制给子类，而去引用
• 子类继承父类后可以重写父类中的方法，叫做 重写
• 子类重写父类的方法，依然可以使用super().父类方法名()的方式调用父类的方法
• 子类中如果定义了父类中不存在的方法，称为对父类的扩展

• 一个父类可以被多个子类继承，还可以存在 链式继承 。

  • 链式继承：A类继承了B类，B类继承了C类，C类继承了D类。。。

单继承和多继承

单继承

单继承：一个类只能继承一个父类的方式。

语法格式:

class 父类():
    pass
class 子类(父类):
    pass

多继承

多继承：一个类去继承多个父类的方式。

语法格式:

class 父亲():
    pass
class 母亲():
  pass
class 子类(父亲,母亲):
    pass

菱形继承（钻石继承）

    A
  B   C
    D
# D类去继承了B类和C类，然后B类和C类又分别继承了A类，这种继承关系称为 菱形继承

问题：在这种菱形继承关系中，类与类的关系，及super()调用时的顺序

'''
在定义类后，程序会自动生成一个继承的列表 MRO （Method Realtion Order） 方法关系列表
MRO列表生成原则：
    1. 子类永远在父类的前面
    2. 同一等级的类，按照子类中的继承顺序摆放
    3. 先子类，后父类的顺序原则，最终的类时系统提供的object类
MRO的调用方法
类名.mro()
'''
C.mro()
# [<class 'C'>, <class 'F'>, <class 'M'>, <class 'HuMan'>, <class 'object'>]
# super()在调用时，并不是查找父类，而是去MRO列表上找上一个类。
# super()方法在调用时，会自动把当前self传入到上一级的类的方法中

类关系检测 issubclass()

issubclass() 检测一个类是否时另一个类的子类

# 检测一个类是否是另一个类的子类
res = issubclass(D,B) # True 检测D类是不是B类的子类
res = issubclass(D,C) # True 检测D类是不是C类的子类
res = issubclass(D,A) # True 检测D类是不是A类的子类
res = issubclass(A,D) # False 检测A类是不是D类的子类

多态

对于同一个方法，由于调用的对象不同，产生了不同形态的结果

示例：

#  多态 普通版本
# 对于同一个方法，由于调用的对象不同（或者传入的对象不同），最终实现了不同的结果
# 定义电脑类
class Computer():
    # 在电脑类中定义一个 sub 的规范的接口 方法
    def usb(self,obj):
        obj.start()
# 定义鼠标类
class Mouse():
    def start(self):
        print('鼠标启动成功，可以双击单击嗨起来。。。')
# 定义键盘类
class KeyBord():
    def start(self):
        print('键盘启动成功了，赶紧双击666。。。')
# 定义 U盘 类
class Udisk():
    def start(self):
        print('U盘启动了，赶紧检查一下我的种子还在不在。。。')
# 实例化对象
c = Computer()  # 电脑对象
m = Mouse()     # 鼠标对象
k = KeyBord()   # 键盘对象
u = Udisk()     # u盘对象
# 把不同的设备插入到电脑的usb的接口中
c.usb(m)
c.usb(k)
c.usb(u)