面向对象的继承

一：继承定义

是一种创建新类的方式，在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

猜你喜欢