Python全栈之路系列----之-----面向对象3(继承与派生)

继承

什么是继承

继承是类中提供的一种新语法,继承：什么是什么的关系  例如非洲人,亚洲人,欧洲人等都是人

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类　

Python的类可以继承多个类，Java和C#中则只能继承一个类

Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

单继承与多继承,语法和格式

单继承
class <类名>(父类名)
      <代码快>

类的多重继承
class 类名(父类1,父类2,....,父类n)
       <代码块>

　　

继承与抽象

抽象:就是把两个类,或者多个类的共同点(相似部分)抽象成为一个父类

继承:就是基于抽象的结果,把父类的属性和方法借给所有子类去调用

• 继承与抽象 是一对
• 先抽象 后继承
• 抽象是从小到大 从下到上 , 继承是从大到小 从上到下
• 子类会继承父类的所有方法和属性

查看子类的父类的方法
　　print(Cat.__bases__)#查看他的父类

例一  抽象出父类

继承是类中提供的一种新语法
#面向对象三大特性：封装 继承 多态
#简易的继承
#继承：什么是什么的关系
    #他大舅打二舅都是他舅
    #高桌子低板凳都是木头

# #狗
# class Dog:   狗有吃 喝 睡 叫等方法
#     def eat(self):
#         print('eating')
#
#     def drink(self):
#         print('drinking')
#
#     def sleep(self):
#         print('sleeping')
#
#     def say(self):
#         print('汪汪汪')
#
# #猫
# class Cat:  猫也有同样的方法
#     def eat(self):
#         print('eating')
#
#     def drink(self):
#         print('drinking')
#
#     def sleep(self):
#         print('sleeping')
#
#     def say(self):
#         print('喵喵喵')


把他们抽象成一个父类,动物类

class Animal:        #父类、超类    
    def eat(self):
        pass

# class Bnimal:
#     def drink(self):
#         pass

# class Dog(Animal,Bnimal): #子类、派生类 #括号里面 什么是什么 狗是动物 继承
#     pass
# class Cat(Animal):   #子类、派生类#子类cat继承父类Animal
#     pass

print(Dog.__bases__)
#继承 抽象

类的继承调用

• 在继承中子类可以继承父类的所有属性和方法
• 但是当 父类和子类中有同名的方法是 一定是调用子类的方法
• 如果想使用 父类该方法的功能 需要借助super 方法
• 谁（对象）调用方法，方法中的self就指向谁

例二  父类的调用

class A:
    def get(self):
        self.say()

    def say(self):
        print('AAAAA')

class B(A):
    def say(self):
        print('BBBBB')

b = B()
b.get()

父类的调用

例三 代码理解

父类 animal
class Animal:  #动物类
    def __init__(self,name):#初始化
        self.name = name

    def eat(self):#方法
        print('%s eating %s'%(self.name,self.food))#字符串拼接,拼接的是属性

    def drink(self):
        print('drinking')

    def sleep(self):
        print('sleeping')

#狗
class Dog(Animal):#子类继承父类
    def __init__(self,name):
        # Animal.__init__(self,name)    #经典类的调用父类中方法的方式
        super().__init__(name) #新式类的调用
        self.food = '狗粮'    #定义一个属性

    def say(self):#子类的方法
        print('汪汪汪')

#猫
class Cat(Animal):
    def __init__(self,name):
        super().__init__(name)  #新式类
        self.food = '猫粮'

    def say(self):
        print('喵喵喵')

wang = Dog('alex')
ha2 = Dog('二哈')
wang.eat()
ha2.eat()

c = Cat('egon')
c.eat()


在继承中
子类可以继承父类的所有属性和方法
但是 当父类和子类中有同名方法的时候 一定调用子类的
如果想使用父类该方法的功能 需要借助super方法

动物类
    名字 粮食
    吃 喝 睡 叫
狗类
    会游泳
鸟类
    会飞

class Animal:
    def __init__(self,name,food):
        self.name = name
        self.food = food
        self.family = '刘老师家'

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

class Dog(Animal):
    def __init__(self,name):
        super().__init__(name, '狗粮')
        self.family = '景弘家'


    def swim(self):
        print('%s is swimming'%self.name)

class Bird(Animal):
    def fly(self):
        print('%s is flying'%(self.name))

teddy = Dog('熊二')   #init
teddy.eat()
teddy.swim()
print(teddy.family)


好鸟 = Bird('花姑娘','虫子')
print(好鸟.family)
对象 可以调用自己本类和父类的所有方法和属性 先调用自己的 自己没有才调父类的
谁（对象）调用方法，方法中的self就指向谁

派生

　　派生:子类中添加子类自己新的属性或者新的方法(不会影响到父类)

　　　　需要注意的是对象 可以调用自己本类和父类的所有方法和属性

　　　　但是会先调用自己的 , 自己没有才会调父类的

　　　　父类名称不要与其他类名称相同,会引起计算机歧义,达不到想要的结果

在python3中，子类执行父类的方法也可以直接用super方法.

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

class B(A):
    def hahaha(self):
        # super(B,self).hahaha()
        super().hahaha()
        print('B')

b = B()
b.hahaha()
# super(B,b).hahaha()

 例四 派生的调用与理解

游戏的例子

class Animal:  #父类 超类 基类
    def __init__(self,name,blood,aggr):
        self.name = name
        self.blood = blood
        self.aggr = aggr

class Person(Animal):   #继承的语法 Person是子类
    def __init__(self, name, blood, aggr,RMB):
        super(Person, self).__init__(name,blood,aggr)
        self.qian=RMB

    def attack(self,dog):
        dog.blood -= self.aggr

class Dog(Animal):   #Dog是子类
    def __init__(self, name, blood, aggr, pinzhong):
        super().__init__(name,blood,aggr)
        self.breed= pinzhong           #派生属性

    def bite(self,person):             #派生方法
        person.blood -= self.aggr

alex  = Person('alex',250,12,1000000)   #钱
egg = Dog('egg',25000,20,'金毛')       #品种

# 什么是什么  ：圆和环组合
继承：单继承、多继承
class A:
    pass

class B(A):
    pass
抽象 : 猪坚强-猪-动物
先抽象再继承 ：猪继承动物类
父类 超类 基类

子类 派生类 （派生属性 派生方法）
子类的对象要去调用方法或者属性：自己有的调自己的，自己没有的调父类的
self是什么：谁调用就是谁
子类的对象调用父类的方法，在父类方法中的self是子类的对象
class Foo:
    def get_test(self):
        self.test()
    def test(self):
        pass

class Son(Foo):
    def test(self):
        pass
f = Son()
f.get_test()

super:如果自己有还要用子类对象调父类的
# super(子类名，子类对象).父类方法名
class Foo:
    def get_test(self):
        self.test()
    def test(self):
        pass

class Son(Foo):
    def test(self):
        super().test()  #调用父类的test
        super(Son,self).test()  #调用父类的test

s = Son()
f = Foo()
f.test(s)
# s = Son()
# s.test()
# 在类外
# super(Son,s).test()
# 在类内
# super(Son,self).test()
# super().test()