繼承和組合

一、組合

組合：組合指的是，在一個類中以另外一個類的對象（也就是實例）作為數據屬性，稱為類的組合

　　　也就是說：一個類的屬性是另一個類的對象，就是組合

例子：

　　圓環是由兩個圓組成的，圓環的面積就是外圓的面積減去內圓的面積。圓環的周長就是內圓的周長加上外圓的周長，這個時候，我們首先設計一個圓形類，計算一個圓的面積和圓的周長。然后在‘圓環類’組合圓形的實例作為自己的屬性來用（這樣的目的就是為了不用在寫面積和周長的方法了，直接組合圓類的面積和方法去求解。減少了代碼的重用）

from math import pi
class Circle:
    def __init__(self,r):
        self.r=r
    def perimater(self):
        return 2*pi*self.r
    def area(self):
        return pi*self.r*self.r
# print(Circle.perimater('r',2))
# print(Circle.area('r',3))


class Circle_ring: #定義一個圓環類
    def __init__(self,outside_r,inside_r):
        outside_bijiao = max(outside_r,inside_r)
        intside_bijiao = min(outside_r, inside_r)
        self.outsize_circle = Circle(outside_bijiao) #實例化一個大圓形  作為self.outside_circle屬性的值
        self.intsize_circle = Circle(intside_bijiao) #實例化一個小圓環
    def area(self):
        return self.outsize_circle.area()-self.intsize_circle.area()
    def perimater(self):
        return self.intsize_circle.perimater()+self.outsize_circle.perimater()


r1 = Circle_ring(10,20)  #實例化
print(r1.area())
print(r1.perimater())

組合的兩種方式:1.在__init__方法里面組合
             2.在外面組合

class BirthDate:
    def __init__(self,year,month,day):
        self.year=year
        self.month = month
        self.day = day
class Course:
    def __init__(self,name,price,period): #period為周期
        self.name =name
        self.price = price
        self.period = period
class Teacher:
    def __init__(self,name,salary,year,month,day,price,period): #那么這個里面也要把該有的屬性傳進去
        self.birth = BirthDate(year,month,day) #在里面組合(將BirthDate里面有的屬性傳入進去)
        self.course=Course(name,price,period)
        self.name = name
        self.salary = salary
# 實例化方法一:
egg = Teacher('egon',2000,1999,12,2,'6 months','15800')  #也要實例化，Teacher類里面的屬性都得實例化
print(egg.birth.month)  #當然老師也有生日，就讓egg.birth.month
print(egg.course.period)

# 實例化方法二:
egg.birth=BirthDate(1996,22,4)
print(egg.birth.month)

class BirthDate:
    def __init__(self,year,month,day):
        self.year=year
        self.month = month
        self.day = day
class Course:
    def __init__(self,name,price,period): #period為周期
        self.name =name
        self.price = price
        self.period = period
class Teacher:
    def __init__(self,name,salary,course):
        self.name = name
        self.salary = salary
        self.course = course
#
# #在外面組合。（組合就是一個類的屬性是另一個類的對象）

egg = Teacher('egon',2000,'python')
egg.birth=BirthDate(1996,22,4) #直接給egg一個birth的屬性，
print(egg.birth.year)

egg.course =Course('python','6 months',15800)
print(egg.course.period)

二、繼承

1.繼承是一種創建新類的方式

2.新建的類可以創建一個或多個父類，父類有稱為基類或者超類

3.新建的類稱為派生類或者子類

在python中類的繼承分為：單繼承或多繼承

class ParentClass1: #定義父類
    pass

class ParentClass2: #定義父類
    pass

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

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

4.查看所有繼承的父類

print(Person.__bases__)      #__base __只查看從左到右繼承的第一個子類，__bases__則是查看所有繼承的父類

如果沒有指定父類，python會默認繼承object類，object是所有python的父類。

 

經典類：在python2中，class Dad: 不會繼承object，這樣的類叫做經典類（它叫經典類，不是因為它經典，而是因為它比較老）

新式類：在python3中，python會默認繼承object類（一切皆對象）

　　　　class Dad  就相當於python2中的  class Dad（object）  #新式類

而且python3中沒有經典類了

5.繼承與抽象（先抽象后繼承）

抽象：抽取類似或者說比較像的部分（也就是提取一類事物的特點，范圍越來越大，共性越來越少）

　　　 是從大范圍到小范圍的過程

繼承：是基於抽象的過程，通過編程語言去實現它，肯定是先經歷抽象這個過程，才能通過繼承的方式去表達出抽象的結構

　　    是從小范圍到大范圍的過程

6.派生：（相對論）

　　1.在父類的基礎上產生子類，產生的子類就叫做派生類

　　2.父類里沒有的方法，在子類中有了，這樣的方法就叫做派生方法。

　　3.父類里有，子類也有的方法，就叫做方法的重寫（就是把父類里的方法重寫了）

7.注意的幾個概念：

　　1.子類可以使用父類的所有屬性和方法

　　2.如果子類有自己的方法，就執行自己的；如果子類沒有自己的方法，就會找父類的。

　　3.如果子類里面沒有找到，父類里也沒有找到，就會報錯

　　4.如果子類中實現了調用父類的方法

　　　　在類內：super(子類，self).方法名（）  supper().__init__(參數)

　　　　在類外：super(子類名，對象名).方法名（）

8.繼承的實例

class Animal:      #父類  基類  超類
    def __init__(self,name,life_value,aggr):
        self.name= name
        self.life_value = life_value
        self.aggr = aggr  #攻擊力
    def eat(self):
        self.life_value += 10  #誰調誰的血量就增加

class Person(Animal):  #子類  派生類
    def __init__(self, money, name, life_value, aggr):
        super().__init__(name, life_value, aggr)
        self.money = money  #派生出來的一個屬性
    def attack(self,enemy):    #人的派生方法
        #enemy.life_value = enemy.life_value - self.aggr
        enemy.life_value -= self.aggr

class Dog(Animal): #子類  派生類
    def __init__(self,name,breed, life_value,aggr):
        # Animal.__init__(self,name,breed, life_value,aggr)#讓子類執行父類的方法 就是父類名.方法名（參數），連self都得傳
        super().__init__(name,life_value,aggr) #super關鍵字  ，都不用傳self了，在新式類里的
        # super(Dog,self).__init__(name,life_value,aggr)  #上面super是簡寫
        self.breed = breed
    def bite(self,person):   #狗的派生方法
        person.life_value -= self.aggr
    def eat(self):  #父類方法的重寫
        super().eat()
        print('dog is eating')

# ha2 = Dog('旺財','哈士奇',20000,100)
# egg = Person('egon',500,1000,50)
# print(egg.aggr)
# print(ha2.aggr)
# egg.eat()
# print(egg.life_value)
#
# egg.eat()
# print(egg.life_value)
#
# ha2.eat()
# print(ha2.life_value)
#
# print(egg.life_value)
# ha2.bite(egg)
# print(egg.life_value)
#

ha2 = Dog('牛頭梗','旺財',20000,100)
print(ha2.life_value)
ha2.eat()  #如果父類有的方法子類里面也有，那么就叫做方法的重寫，就不執行父類的了，去執行子類了
print(ha2.life_value)


super(Dog,ha2).eat() #生掉父類的方法，但是不推薦這樣用
print(ha2.life_value)

#在繼承中，如果子類有的方法就執行子類的
# 如果子類沒有的方法就執行父類的