Python-面向对象（中）

目录

一、继承介绍以及单继承

1、现实中的继承

2、程序中的继承

二、单继承

三、多继承

四、子类重写父类的同名属性和方法

五、多层继承

六、调用父类的方法super()

---

一、继承介绍以及单继承

1、现实中的继承

在现实生活中，继承一般指的是子女继承父辈的财产，如下图

搞不好,结果如下... 

 

2、程序中的继承

在程序中，继承描述的是多个类之间的所属关系。

如果一个类A里面的属性和方法可以复用，则可以通过继承的方式，传递到类B里。

那么类A就是基类，也叫做父类；类B就是派生类，也叫做子类。

# 父类
class A(object):
    def __init__(self):
        self.num = 10

    def print_num(self):
        print(self.num + 10)
# 子类
class B(A):
    pass

b = B()
print(b.num) 
b.print_num()

 

二、单继承

单继承：子类只继承一个父类

很久很久以前（long long ago:）曾经有这样一个故事：

情节：煎饼果子老师傅在煎饼果子界摸爬滚打几十年，拥有一身精湛的煎饼果子技术，并总结了一套"古法煎饼果子配方"。

可是老师傅年迈已久，在嗝屁之前希望把自己的配方传承下去，于是老师傅把配方传给他的徒弟大猫...

代码：

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'

    def make_cake(self):
        print('按照<%s>制作了一份煎饼果子...'%self.kongfu)

class Prentice(Master):
    pass

laoli = Master()
print(laoli.kongfu)
laoli.make_cake()
print('*'*45)
damao = Prentice()
print(damao.kongfu)
damao.make_cake()

结果：

说明：

虽然子类没有定义__init__方法初始化属性，也没有定义实例方法，但是父类有。所以只要创建子类的对象，就默认执行了那个继承过来的__init__方法

总结：

子类在继承的时候，在定义类时，小括号()中为父类的名字 父类的属性、方法，会被继承给子类

剧情发展：

大猫掌握了师傅的配方，可以制作古法煎饼果子。但是大猫是个爱学习的好孩子，他希望学到更多的煎饼果子的做法，于是通过百度搜索，找到了一家煎饼果子培训学校。（多继承）

 

三、多继承

多继承：

子类继承多个父类

代码demo1：

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'

    def make_cake(self):
        print('[古法]按照<%s>制作了一份煎饼果子...'%self.kongfu)

    def dayandai(self):
        print('师傅的大烟袋...')

class School(object):
    def __init__(self):
        self.kongfu = '现代煎饼果子配方'

    def make_cake(self):
        print('[现代]按照<%s>制作了一份煎饼果子...'%self.kongfu)

    def xiaoyandai(self):
        print('学校的小烟袋...')

class Prentice(School,Master):#多继承 继承了多个父类（School在前）
    pass

damao = Prentice()
print(damao.kongfu)
damao.make_cake()
damao.dayandai()
damao.xiaoyandai()

结果：

 

代码demo2：

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'

    def make_cake(self):
        print('[古法]按照<%s>制作了一份煎饼果子...'%self.kongfu)

    def dayandai(self):
        print('师傅的大烟袋...')

class School(object):
    def __init__(self):
        self.kongfu = '现代煎饼果子配方'

    def make_cake(self):
        print('[现代]按照<%s>制作了一份煎饼果子...'%self.kongfu)

    def xiaoyandai(self):
        print('学校的小烟袋...')

class Prentice(School,Master):#多继承 继承了多个父类（School在前）
    pass

damao = Prentice()
print(damao.kongfu)
damao.make_cake()
#子类的魔法属性决定了属性和方法的查找顺序
print(Prentice.__mro__)
damao.dayandai()#不受重名影响
damao.xiaoyandai()

结果：

说明：

多继承可以继承多个父类，也继承了所有父类的属性和方法

注意：如果多个父类中有同名的 属性和方法，则默认使用第一个父类的属性和方法（根据类的魔法属性mro的顺序来查找）

多个父类中，不重名的属性和方法，不会有任何影响 

剧情发展：

大猫掌握了 师傅的配方 和 学校的配方，通过研究，大猫在两个配方的基础上，创建了一种全新的煎饼果子配方，称之为 "猫氏煎饼果子配方"。（子类重写父类同名属性和方法）

 

四、子类重写父类的同名属性和方法

代码：

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'

    def make_cake(self):
        print('[古法]按照<%s>制作了一份煎饼果子...'%self.kongfu)

class School(object):
    def __init__(self):
        self.kongfu = '现代煎饼果子配方'

    def make_cake(self):
        print('[现代]按照<%s>制作了一份煎饼果子...'%self.kongfu)

class Prentice(School,Master):#多继承 继承了多个父类（School在前）
    def __init__(self):
        self.kongfu = '猫氏煎饼果子配方'

    def make_cake(self):
        print('[猫氏]按照<%s>制作了一份煎饼果子...'%self.kongfu)

damao = Prentice()
print(damao.kongfu)
damao.make_cake()

print(Prentice.__mro__)

结果：

剧情发展：

大猫的新配方大受欢迎，但是有些顾客希望也能吃到古法配方和 现代配方 的煎饼果子...（子类调用父类的同名属性和方法）

代码：

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'

    def make_cake(self):
        print('[古法]按照<%s>制作了一份煎饼果子...'%self.kongfu)

class School(object):
    def __init__(self):
        self.kongfu = '现代煎饼果子配方'

    def make_cake(self):
        print('[现代]按照<%s>制作了一份煎饼果子...'%self.kongfu)

class Prentice(School,Master):#多继承 继承了多个父类（School在前）
    def __init__(self):
        self.kongfu = '猫氏煎饼果子配方'

    def make_cake(self):
        print('执行子类的__init__方法前，self.kongfu属性：%s'%self.kongfu)
        self.__init__()
        print('执行子类的__init__方法后，self.kongfu属性：%s'%self.kongfu)
        print('[猫氏]按照<%s>制作了一份煎饼果子...'%self.kongfu)

    def make_old_cake(self):
        print('执行Master类的__init__方法前，self.kongfu属性：%s'%self.kongfu)
        Master.__init__(self)
        print('执行Master类的__init__方法前，self.kongfu属性：%s' % self.kongfu)
        Master.make_cake(self)

    def make_new_cake(self):
        print('执行School类的__init__方法前，self.kongfu属性：%s'%self.kongfu)
        School.__init__(self)
        print('执行School类的__init__方法前，self.kongfu属性：%s' % self.kongfu)
        School.make_cake(self)

damao = Prentice()
damao.make_cake()
print('-'*50)
damao.make_old_cake()
print('-'*50)
damao.make_new_cake()
print('-'*50)
damao.make_cake()

结果：

核心点：

无论何时何地，self都表示是子类的对象。在调用父类方法时，通过传递self参数，来控制方法和属性的访问修改。

 

五、多层继承

剧情发展：

大猫的煎饼果子店非常红火，终于有一天，他成了世界首富！！ 但是他也老了，所以他希望把 师傅的配方 和 学校的配方 以及自己的配方 继续传承下去...（多层继承）

代码：

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'

    def make_cake(self):
        print('[古法]按照<%s>制作了一份煎饼果子...'%self.kongfu)

class School(object):
    def __init__(self):
        self.kongfu = '现代煎饼果子配方'

    def make_cake(self):
        print('[现代]按照<%s>制作了一份煎饼果子...'%self.kongfu)

class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '猫氏煎饼果子配方'
        self.money = 10000 #亿美金

    def make_cake(self):
        self.__init__()
        print('[猫氏]按照<%s>制作了一份煎饼果子...'%self.kongfu)

    def make_old_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_new_cake(self):
        School.__init__(self)
        School.make_cake(self)

class PrenticePrentice(Prentice):
    pass

pp = PrenticePrentice()
pp.make_cake()
pp.make_new_cake()
pp.make_old_cake()

print(pp.money)

结果：

剧情发展：

大猫觉得配方传承下去没问题，但是钱是辛辛苦苦挣得血汗钱，不想传给徒弟。（私有权限，下一章）

 

六、调用父类的方法super()

代码：

class Animal(object):

    def play(self):
        print("动物都有各自的玩法")

class Cat(Animal):  # 方法的重写/覆盖
    def play(self):
        super().play()
        print("猫喜欢玩球")

c = Cat()
c.play()

结果：