面向對象的繼承1

一：繼承定義

是一種建立新類的方式，在Python中，新建的類能夠繼承一個或多個父類，父類叫作幾類和超類，新建的類叫作子類和派生類。

class Fatherclass:pass
class Motherclass:pass
class Childclass(Fatherclass):pass #單繼承
class Childclass(Fatherclass,Motherclass):pass#多繼承

注意：多繼承父類（基類）之間用，隔開

 

二：如何查看（類名.__base__方法  查看第一個父類）或（類名.__base__方法，查看全部父類）

在Python3中全部的類都繼承object

print(Childclass.__base__)#查看第一個父類
print(Childclass.__bases__)#查看全部父類
print(Fatherclass.__bases__)#object (python3全部的類都繼承object)
print(Motherclass.__bases__)

注意： 提示：若是沒有指定基類，python的類會默認繼承object類，object是全部python類的基類，它提供了一些常見方法（如__base(s)__）的實現

 

三：抽象與繼承（先繼承在抽象）

抽象就是抽取類中類似或者相像的部分

抽象分紅兩個層次： 

1.將奧巴馬和梅西這倆對象比較像的部分抽取成類； 

2.將人，豬，狗這三個類比較像的部分抽取成父類。

抽象最主要的做用是劃分類別（能夠隔離關注點，下降複雜度）

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

抽象只是分析和設計的過程當中，一個動做或者說一種技巧，經過抽象能夠獲得類

 

 

例題1：

貓狗大戰*

# 貓類 : 吃eat 喝drink 睡sleep 爬樹climb
# 狗類 : 吃eat 喝drink 睡sleep 看家watch
class Pet:
    def __init__(self,name,kind,food):
        self.name = name
        self.kind = kind
        self.food = food

    def eat(self):
        print('%s吃%s'%(self.name,self.food))

    def drink(self):
        print('%s在喝水'%self.name)

    def sleep(self):
        print('%s在睡覺' % self.name)

class Cat(Pet):
    def climb(self):      # 派生方法
        print('%s在爬樹' % self.name)

class Dog(Pet):
    def watch(self):     # 派生方法
        print('%s在看家' % self.name)

tom = Cat('Tom','暹羅貓','貓糧')  # 子類使用名字(方法和靜態變量),若是在子類中沒有,就使用父類的\
# Cat('Tom','暹羅貓','貓糧') 實例化
# 實例化這個類
    # 建立一個空對象
    # 執行__init__方法:子類沒有用父類的
hei = Dog('小黑','2哈','狗糧')
tom.eat()
hei.eat()
tom.climb()
hei.watch()

打印結果：

Tom吃貓糧
小黑吃狗糧
Tom在爬樹
小黑在看家

例題2 人狗大戰

class Animal: # 動物
    def __init__(self,name,aggr,hp):  #方法 動態屬性  內置的雙下方法
        self.name = name    # 對象屬性 實例屬性
        self.aggr = aggr
        self.hp = hp

class Person(Animal):    # 類名 Person
    def __init__(self,name,sex,aggr,hp):
        self.sex = sex   # 派生屬性
        Animal.__init__(self,name,aggr,hp)
        super().__init__(name,aggr,hp)

    def attack(self,dog):  # 自定義方法
        print('%s打了%s'%(self.name,dog.name))
        dog.hp -= self.aggr

class Dog(Animal):
    def __init__(self,name,kind,aggr,hp):
        self.kind = kind   # 派生屬性
        Animal.__init__(self,name,aggr,hp)
    def bite(self,person):
        print('%s咬了%s'%(self.name,person.name))
        person.hp -= self.aggr

alex = Person('alex','不詳',1,250)
# 首先建立一個Person的對象,
# 初始化:找init方法,本身有調用本身的

# 父類和子類擁有同名的方法時,子類的對象只會調用子類的
# 若是想要調用父類的方法,須要 父類名.方法名(self,其餘參數)
hei = Dog('小黑','teddy',260,10000)
alex.attack(hei)
hei.bite(alex)

注意：父類和子類有相同的方法時，子類對象只能調用子類的

    若是想要調用父類的方法，須要父類名.方法名（self,其餘參數），如例子中 Animal.__init__（self,name,age,aggr,hp）

         也能夠用super().__init__（name,age,aggr,hp）

注意：super加括號，後面不須要傳self參數，其餘參數不變

 

例題3 

class Foo:
    def __init__(self):
        self.func()

    def func(self):
        print('in Foo')

class Son(Foo):
    def func(self):
        print('in son')

f = Foo()
Son()

f = Foo() 是執行foo類全部過程，因此打印'in Foo'

Son()       是執行son類過程，沒有的話找父類，有就找子類，本題有，若是class Son(fool):pass就會在父類找啦

打印結果： in Foo  in son