面向对象的继承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