面向對象 - 繼承:
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'>] 繼承
面向對象 - 組合：
組合：什么有什么的關系 繼承是：什么是什么的關系 都實現了代碼重用
對象的屬性 被賦值 一個對象/一個列表，列表有多個對象 等

1 class People: 2 def __init__(self,name,age,sex): 3 self.name=name 4 self.age=age 5 self.sex=sex 6 7 class Teather(People): 8 def __init__(self,name,age,sex,level,salary): 9 super().__init__(name,age,sex) 10 self.level=level 11 self.salary=salary 12 13 def teach(self): 14 print('%s is teaching'%self.name) 15 16 class Student(People): 17 def __init__(self,name,age,sex,class_time): 18 super().__init__(name,age,sex) 19 self.class_time=class_time 20 21 def learn(self): 22 print('%s is learning'%self.name) 23 24 class Course: 25 def __init__(self,course_name,course_price,course_period): 26 self.course_name=course_name 27 self.course_price=course_price 28 self.course_period=course_period 29 30 def tell_info(self): 31 print('課程名<%s> 課程價錢<%s> 課程周期<%s>'%(self.course_name,self.course_price,self.course_period)) 32 33 class Date: 34 def __init__(self,year,month,day): 35 self.year=year 36 self.month=month 37 self.day=day 38 39 def tell_info(self): 40 print('%s-%s-%s'%(self.year,self.month,self.day)) 41 42 tea1=Teather('alex',18,'male',10,3000) 43 tea2=Teather('egon',28,'female',8,2000) 44 45 stu1=Student('alice',12,'female','08:30:00') 46 stu2=Student('lily',16,'male','09:00:00') 47 48 python=Course('python',2000,'3mons') 49 linux=Course('linux',3000,'4mons') 50 51 # date=Date(1990,10,11) 52 53 # tea1.teach() 54 # stu1.learn() 55 # python.tell_info() 56 # date.tell_info() 57 58 # tea1.course=[python,linux] 59 # tea1.course[0].tell_info() 60 # tea1.course[1].tell_info() 61 # 62 # stu1.course=python 63 # print(stu1.course.course_name) 64 65 # stu1.course1=python 66 # stu2.course2=linux 67 # print(stu1.course1.course_name) 68 # print(stu2.course2.course_period) 69 70 # stu1.course=[] 71 # stu1.course.append(python) 72 # stu1.course.append(linux) 73 # stu1.course[0].tell_info() 74 # stu1.course[1].tell_info() 75 76 # stu1.birth=Date(2000,10,11) 77 # stu1.birth.tell_info() 組合

轉載于:https://www.cnblogs.com/alice-bj/p/8544512.html

總結

以上是生活随笔為你收集整理的面向对象 - 继承/组合 - 总结的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。