022_繼承_派生_多繼承_磚石繼承

1，什麼是繼承

　　繼承是一種建立新類的方式，在python中，新建的類能夠繼承一個或多個父類，父類又可稱爲基類或超類，新建的類稱爲派生類或子類

2，python中類的繼承分爲：單繼承和多繼承

　　2.1，定義類時，類名後面的括號是用來代表關係的，不是用來傳參的。

class ParentClass1: #定義父類
    pass

class ParentClass2: #定義父類
    pass

class SubClass1(ParentClass1): #單繼承，基類是ParentClass1，派生類是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多繼承，用逗號分隔開多個繼承的類
    pass

　　2.2，查看繼承

>>> SubClass1.__bases__ #__base__只查看從左到右繼承的第一個子類，__bases__則是查看全部繼承的父類
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
>>>ParentClass1.__bases__
(<class 'object'>,)	#任何一個沒有父類的類都是object的子類。python3中沒有繼承的默認繼承object類。

3，在定義類時，在默認執行__init__(self)以前，就會默認創建了一個空白對象self。

　　在當前的代碼中，建立dog對象時，經過Dog類建立，此時已經建立了Dog的空白對象self，在默認執行__init__(self)時，本身並無，就會執行父類裏的，所以，傳給父類的__init__(self)方法的對象是Dog的空白對象self。因此，執行裏面的self.func()時，應該是Dog的func()

class Animal:
    def __init__(self):
        print('執行Animal.__init__')
        self.func()
 
class Dog(Animal):
    def func(self):
        print('Dog.func')
 
dog = Dog()
# 結果
# 執行Animal.__init__
# Dog.func

4，繼承

　　在開發程序的過程當中，若是咱們定義了一個類A，而後又想新創建另一個類B，可是類B的大部份內容與類A的相同時
　　咱們不可能從頭開始寫一個類B，這就用到了類的繼承的概念。
　　經過繼承的方式新建類B，讓B繼承A，B會‘遺傳’A的全部屬性(數據屬性和函數屬性)，實現代碼重用

class Animal:
    '''
    人和狗都是動物，因此創造一個Animal基類
    '''
    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 人和狗都有本身的暱稱;
        self.aggressivity = aggressivity  # 人和狗都有本身的攻擊力;
        self.life_value = life_value  # 人和狗都有本身的生命值;

    def eat(self):
        print('%s is eating'%self.name)

class Dog(Animal):
    pass

class Person(Animal):
    pass

egg = Person('egon',10,1000)
ha2 = Dog('二愣子',50,1000)
egg.eat()
ha2.eat()

5，supper

　　在子類中，新建的重名的函數屬性，在編輯函數內功能的時候，有可能須要重用父類中重名的那個函數功能，應該是用調用普通函數的方式，即：類名.func()，此時就與調用普通函數無異了，所以即使是self參數也要爲其傳值.
　　在python3中，子類執行父類的方法也能夠直接用super方法 

class A:
    def hahaha(self):
        print('A')

class B(A):
    def hahaha(self):
        super().hahaha() # 「supper(類名,對象名).方法名」 #super(B,self).hahaha()，
						# 在本類中參數能夠不寫，默認傳本類的類名和對象。 此方法也可用於類外。
        # A.hahaha(self) # 用調用普通函數的方式（同上句）
        print('B')

a = A()
b = B()
b.hahaha()
super(B,b).hahaha()

6，派生

class Animal:
    '''
    人和狗都是動物，因此創造一個Animal基類
    '''
    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 人和狗都有本身的暱稱;
        self.aggressivity = aggressivity  # 人和狗都有本身的攻擊力;
        self.life_value = life_value  # 人和狗都有本身的生命值;

    def eat(self):
        print('%s is eating'%self.name)

class Dog(Animal):
    '''
    狗類，繼承Animal類
    '''
    def __init__(self,name,breed,aggressivity,life_value):
        super().__init__(name, aggressivity, life_value) #執行父類Animal的init方法
        self.breed = breed  #派生出了新的屬性

    def bite(self, people):
        '''
        派生出了新的技能：狗有咬人的技能
        :param people:  
        '''
        people.life_value -= self.aggressivity

    def eat(self):
        # Animal.eat(self)
        #super().eat()
        print('from Dog')

class Person(Animal):
    '''
    人類，繼承Animal
    '''
    def __init__(self,name,aggressivity, life_value,money):
        #Animal.__init__(self, name, aggressivity, life_value)
        #super(Person, self).__init__(name, aggressivity, life_value)
        super().__init__(name,aggressivity, life_value)  #執行父類的init方法
        self.money = money   #派生出了新的屬性

    def attack(self, dog):
        '''
        派生出了新的技能：人有攻擊的技能
        :param dog: 
        '''
        dog.life_value -= self.aggressivity

    def eat(self):
        #super().eat()
        Animal.eat(self)    #若是既想實現新的功能也想使用父類本來的功能，還須要在子類中再調用父類
        print('from Person')

egg = Person('egon',10,1000,600)
ha2 = Dog('二愣子','哈士奇',10,1000)
print(egg.name)
print(ha2.name)
egg.eat()

7，繼承順序

8，多繼承中的磚石繼承

# 父類中沒有的屬性 在子類中出現 叫作派生屬性
# 父類中沒有的方法 在子類中出現 叫作派生方法
# 只要是子類的對象調用，子類中有的名字 必定用子類的，子類中沒有才找父類的，若是父類也沒有報錯
# 若是父類 子類都有 用子類的
    # 若是還想用父類的，單獨調用父類的:
    #       父類名.方法名 須要本身傳self參數
    #       super().方法名 不須要本身傳self
# 正常的代碼中 單繼承 === 減小了代碼的重複
# 繼承表達的是一種 子類是父類的關係

9，面向對象的的組合

　　9.1，什麼是組合

<1>軟件重用的重要方式除了繼承以外還有另一種方式，即：組合

<2>組合指的是，在一個類中以另一個類的對象做爲數據屬性，稱爲類的組合

<3>當類之間有顯著不一樣，而且較小的類是較大的類所須要的組件時，用組合比較好

class Weapon:
    def prick(self, obj):  # 這是該裝備的主動技能,扎死對方
        obj.life_value -= 500  # 假設攻擊力是500

class Person:  # 定義一我的類
    role = 'person'  # 人的角色屬性都是人

    def __init__(self, name):
        self.name = name  # 每個角色都有本身的暱稱;
        self.weapon = Weapon()  # 給角色綁定一個武器;
        
egg = Person('egon')
egg.weapon.prick() 
#egg組合了一個武器的對象，能夠直接egg.weapon來使用組合類中的全部方法

　　9.2，圓環計算組合

　　圓環是由兩個圓組成的，圓環的面積是外面圓的面積減去內部圓的面積。圓環的周長是內部圓的周長加上外部圓的周長。

　　這個時候，咱們就首先實現一個圓形類，計算一個圓的周長和麪積。而後在"環形類"中組合圓形的實例做爲本身的屬性來用

from math import pi class Circle: ''' 定義了一個圓形類； 提供計算面積(area)和周長(perimeter)的方法 '''
    def __init__(self,radius): self.radius = radius def area(self): return pi * self.radius * self.radius def perimeter(self): return 2 * pi *self.radius circle =  Circle(10) #實例化一個圓
area1 = circle.area() #計算圓面積
per1 = circle.perimeter() #計算圓周長
print(area1,per1) #打印圓面積和周長

class Ring: ''' 定義了一個圓環類 提供圓環的面積和周長的方法 '''
    def __init__(self,radius_outside,radius_inside): self.outsid_circle = Circle(radius_outside) self.inside_circle = Circle(radius_inside) def area(self): return self.outsid_circle.area() - self.inside_circle.area() def perimeter(self): return  self.outsid_circle.perimeter() + self.inside_circle.perimeter() ring = Ring(10,5) #實例化一個環形
print(ring.perimeter()) #計算環形的周長
print(ring.area()) #計算環形的面積

圓環加計算

　　9.3，能夠先實例化在傳給屬性

　　　　用組合的方式創建了類與組合的類之間的關係，它是一種‘有’的關係,好比教授有生日，教授教python課程

class BirthDate: def __init__(self,year,month,day): self.year=year self.month=month self.day=day class Couse: def __init__(self,name,price,period): self.name=name self.price=price self.period=period class Teacher: def __init__(self,name,gender,birth,course): self.name=name self.gender=gender self.birth=birth self.course=course def teach(self): print('teaching') p1=Teacher('egon','male', BirthDate('1995','1','27'), Couse('python','28000','4 months') ) print(p1.birth.year,p1.birth.month,p1.birth.day) print(p1.course.name,p1.course.price,p1.course.period) ''' 運行結果: 1 27 python 28000 4 months '''

先實例化在傳給屬性