面向对象

1.继承：指的是类与类之间的关系，是一种什么是什么的关系，继承的功能是解决代码的重用问题，继承是一种创建新类的方式
python 中新建的类可以继承一个或多个父类（基类或超类）
新建的类称为派生类或子类

对象之间相似的特征-------类
类之间相似的特征 ---- 父类

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。

# class ParentClass1:
#     pass
#
# class ParentClass2:
#     pass
#
# class SubClass1(ParentClass1):  # 子类/派生类  父类/基类
#     pass
#
# class SubClass2(ParentClass1,ParentClass2):
#     pass
#
# print(SubClass1.__bases__)
# print(SubClass2.__bases__)

class Hero:
    x = 3
    def __init__(self, nickname, life_value, aggressivity):
        self.nickname = nickname
        self.life_value = life_value
        self.aggressivity = aggressivity

    def attack(self, enemy):
        enemy.life_value -= self.aggressivity

class Garen(Hero):
    # x = 2
    pass


class Riven(Hero):
    pass

g1 = Garen('alice',80,30)
# print(g1.__dict__)
# print(g1.nickname,g1.life_value,g1.aggressivity)

# 继承之后的查找顺序 1.对象自己这找 --> 2.对象所在的类里面找 --> 3.父类里面找
# g1.x = 1
# print(g1.x)


# 属性查找的小练习
class Foo:
    def f1(self):
        print('from Foo.f1')
    def f2(self):
        print('from Foo.f2')
        self.f1() #b.f1()
class Bar(Foo):
    d = 1
    def f1(self):
        print('from Bar.f1')

b = Bar()
print(b.__dict__)
b.f2()

2.派生：子类可以添加自己的 新属性 数据属性 函数属性
查找顺序：1.对象本身--》2.对象所在的类里面找--》3.父类里面找

class Hero:
    def __init__(self, nickname, life_value, aggressivity):
        self.nickname = nickname
        self.life_value = life_value
        self.aggressivity = aggressivity

    def attack(self, enemy):
        enemy.life_value -= self.aggressivity

class Garen(Hero):
    camp = 'Demacia'
    def attack(self, enemy):
        print('from Garen Class')

class Riven(Hero):
    camp = 'Noxus'

g1 = Garen('草丛伦',100,30)
r1 = Riven('锐雯雯',80,50)
# print(g1.__dict__)
# print(g1.camp)
# g1.attack(r1)
# print(r1.life_value)
g1.attack(r1)

3.继承的实现原理：python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表
例如：
>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
0.对象本身优先于子类
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

在Java和C#中子类只能继承一个父类，而Python中子类可以同时继承多个父类，如果继承了多个父类，那么属性的查找方式有两种，
分别是：深度优先和广度优先 （本质按列表顺序来） --》只是一种排序的不同方式

python中类分为两种：1.新式类 2.经典类 （py2中）
                 1.新式类 （py3 --> 只有新式类)

#在python2中-》经典类：没有继承object的类，以及它的子类都称之为经典类 ---》深度优先 --> 一条路走到黑
# class Foo:
#     pass
#
# class Bar(Foo):
#     pass
#在python2中-》新式类：继承object的类，以及它的子类都称之为新式类
# class Foo(object):
#     pass
#
# class Bar(Foo):
#     pass
# ------------------------------------------------------
#在python3中-》新式类：一个类没有继承object类，默认就继承object---》广度优先 --》从左到右 ，再到继承object的那个类 返回 在从左到右找
# class Foo:
#     pass
# print(Foo.__bases__)

# --------------------------------------------------------
# 验证多继承情况下的属性查找  -- # F D B X E C A  新式类 --》 广度优先
class A(object):
    def test(self):
        print('from A')

class X(A):  # 注意在这返回了，重新找 因为这里继承了A（object）
    # def test(self):
    #     print('from X')
    pass

class B(X):
    # def test(self):
    #     print('from B')
    pass

class C(A):
    # def test(self):
    #     print('from C')
    pass


class D(B):
    # def test(self):
    #     # print('from D')
    pass

class E(C):
    def test(self):
        print('from E')
    pass


class F(D,E):
    # def test(self):
    #     print('from F')
    pass
# F D B X E C A

print(F.mro())
# [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.X'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

# f = F()
# f.test()