面向对象 - 继承/组合 - 总结

面向对象 - 继承:
1.继承: 类与类之间的关系 什么是什么的关系  eg:人是动物 狗是动物
          功能: 解决代码重用问题, 创建新类的方式,
      类: 可继承一个或多个父类:
          父类 == 基类/超类
          类 == 派生类/子类

          类: 对象之间相似的特征
          父类: 类与类之间相似的特征

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

        继承相关知识:
          1.查看继承哪些类?
              SubClass1.__bases__
          2.父类的属性 都是子类的, 数据属性和函数属性都是公用的 Garen.x is Riven.x == True  Riven.attack is Riven.attack == True
          3.属性查找的顺序:1.对象自己内部找-->2.对象所在的类里面找-->3.父类里面找
2.派生:
        2.1.子类可以添加自己的新属性  数据属性和函数属性
        2.2.子类的属性名和父类的属性名 若相同 子类覆盖父类的属性
3.继承的实现原理:
        3.1.python会计算出一个方法解析顺序列表(MR0),所有基类的线性顺序列表
            F.mro() == 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'>]
        3.2.属性查找：
            0.对象本身优先于子类
            1.子类优先于父类
            2.多个父类会根据（MRO）列表 依次查找
            3.如果对下一个类存在两个合法的选择,选择第一个父类
        3.3.python的类
            py2:
                经典类：没有继承object的类，以及它的子类都称之为经典类 --》深度优先
                新式类：继承object的类，以及它的子类都称之为新式类 --》广度优先
            py3:
                新式类：一个类如果没有继承object的类，就默认继承object --》广度优先
        3.4.属性查找方式：（本质都是按列表mro顺序来的）
            1.深度优先
            2.广度优先

 

    
    4.派生出的方法 重用 父类的属性：
        4.1.指名道姓 不依赖继承
            Hero.attack(self, enemy)
            Hero.__init__(self,nickname,life_value,aggressivity)
        4.2.super() 依赖继承   super() 找的是子类的（MRO）列表中的下一个  C.mro()
            super(Garen, self).attack(enemy)    py2 写法
            super().attack(enemy)               py3 写法
            super().__init__(nickname,life_value,aggressivity)

  1 class ParentClass1:
  2     pass
  3 
  4 class ParentClass2:
  5     pass
  6 
  7 class SubClass1(ParentClass1):
  8     pass
  9 
 10 class SubClass2(ParentClass1,ParentClass2):
 11     pass
 12 
 13 # print(SubClass1.__bases__)
 14 # print(SubClass2.__bases__)
 15 
 16 class Hero:
 17     x=3
 18     def __init__(self,nickname,life_value,aggressivity):
 19         self.nickname=nickname
 20         self.life_value=life_value
 21         self.aggressivity=aggressivity
 22 
 23     def attack(self,enemy):
 24         enemy.life_value-=self.aggressivity
 25         print('父类 里的 attack')
 26 
 27 class Garen(Hero):
 28     # x=2
 29     camp='Demacia'
 30 
 31     def __init__(self,nickname,life_value,aggressivity):
 32         # Hero.__init__(self,nickname,life_value,aggressivity)
 33         # super(Garen, self).__init__(nickname,life_value,aggressivity)
 34         super().__init__(nickname,life_value,aggressivity)
 35         print('garen __init__')
 36 
 37     def attack(self,enemy):
 38         # Hero.attack(self, enemy)
 39         # super(Garen, self).attack(enemy)
 40         super().attack(enemy)
 41         print('子类 里的 attack')
 42 
 43 
 44     def func(self):
 45         print('func')
 46 
 47     def func2(self):
 48         pass
 49 
 50 class Riven(Hero):
 51     camp='Noxus'
 52     pass
 53 
 54 # g=Garen('alice1',50,30)
 55 # g2=Garen('alice2',50,30)
 56 # r=Riven('alex',80,60)
 57 # print(g.__dict__)
 58 # g.attack(r)
 59 
 60 # print(g.camp)
 61 # print(r.camp)
 62 # g.attack(r)
 63 # g.func()
 64 # r.func()
 65 # print(g.x)
 66 
 67 # print(g.__dict__)
 68 # g.x=2
 69 # print(g.x)
 70 # print(r.life_value)
 71 # g.attack(r)
 72 # print(r.life_value)
 73 # print(Garen.x is Riven.x )
 74 # print(Garen.attack)
 75 # print(Riven.attack)
 76 # print(Riven.attack is Riven.attack)
 77 # print(g.attack,id(g.attack))
 78 # print(r.attack,id(r.attack))
 79 # print(id(g))
 80 # print(g.func,id(g.func))
 81 # print(g.func2,id(g.func2))
 82 # print(g2.func,id(g2.func))
 83 # print(g2.func2,id(g2.func2))
 84 # print(g.func is g.attack)
 85 # print(g.func is g.func2)
 86 # print(id(Garen.func),id(Garen.func2))
 87 
 88 class Foo:
 89     def f1(self):
 90         print('from Foo.f1')
 91 
 92     def f2(self):
 93         print('from Foo.f2')
 94         self.f1()
 95 
 96 class Bar(Foo):
 97     d=1
 98     def f1(self):
 99         print('from Bar.f1')
100 
101 # b=Bar()
102 # b.f2()
103 
104 class A:
105     pass
106 
107 class X(A):
108     pass
109 
110 class B(X):
111     pass
112 
113 class C(A):
114     pass
115 
116 class D(B):
117     pass
118 
119 class E(C):
120     pass
121 
122 class F(D,E):
123     pass
124 
125 f=F()
126 # print(f.__dict__)
127 # print(F.mro())
128 # print(F.__mro__)
129 
130 class Foo:
131     pass
132 # class Bar(Foo):
133 #     pass
134 # print(Foo.__bases__)
135 
136 class A:
137     def f1(self):
138         print('from A')
139         super().f1()
140 
141 class B:
142     def f1(self):
143         print('from B')
144 
145 class C(A,B):
146     pass
147 
148 c=C()
149 c.f1()
150 print(C.mro())
151 print(C.__mro__)
152 # [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

继承