面向对象-继承--详细讲解

####################3继承的知识点：############333
# 1.继承的概念
# 2.单继承
# 3.多继承
# 4.子类重写父类的同名属性和方法
# 5.子类调用父类的同名属性和方法
# 6.多层继承
# 7.super（）
# 8.私有属性和私有方法
######### 一。继承的概念############
# class 类名（object）:
#     代码
# python 面向对象继承就是多个类之间的所属关系，即子类默认继承父类的所有属性和方法。
############体验继承##############
# 父类A
class A(object):
    def __init__(self): #初始化
        self.num = 1
    def print_info(self):
        print(self.num)
# #子类B
class B(A):
    pass
result = B()
result.print_info() #继承成功，返回结果1.
# #python 所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。
# # ######################二。单继承#################
# 分析：徒弟继承师傅的煎饼果子所有技术？
#1.师傅类 包含属性及方法
class Master(object):
    '''定义一类师傅类'''
    def __init__(self):
        '''初始化配方'''
        self.kongfu = '[古法煎饼果子配方]'

    def  make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
#2.徒弟类，继承师傅类
class Prentice(Master):
    pass
#3.用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice() #对象：大邱
print(daqiu.kongfu)
daqiu.make_cake()

#############三。多继承####################
# 多继承意思就是一个类同时继承了多个父类
# daqiu拥有了师傅了配方，又在培训学校学习了，说了daqiu拥有了师傅和培训学校的配方。
class Master(object):
    def __init__(self):
        self.kongfu = ['古法煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

class School(object):
    def __init__(self):
        self.kongfu = ['学校的煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

class Prentice(School,Master):
    pass

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

# 结论：如果一个类继承多个类，优先继承第一个类的同名属性和方法。
# ################四：子类重写父类同名方法和属性################
# 分析：daqiu学会了师傅和培训的技术后，自己有研究了一套自己的方法、
class Master(object):
    def __init__(self):
        self.kongfu = ['古法煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
    def __init__(self):
        self.kongfu = ['学校煎饼果子配方']

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[自创的煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()  #有限使用自创的配方和方法

# print(Prentice.__mro__)  #拓展mro顺序，查看父类的继承关系，得到继承顺序。
# 结论：如果子类和父类拥有同名属性和方法，子类创建对象调用方法，运用子类自己的属性和方法。
# 五。子类调用父类的同名方法和属性
# 分析：很多顾客希望吃到古法和培训技术的煎饼果子。
class Master(object):
        '''定义一个师傅类'''
    def __init__(self):
        '''初始化师傅类'''
        self.kongfu = ['古法煎饼果子配方']

    def make_cake(self):
        '''提供方法'''
        print(f'运用{self.kongfu}制作煎饼果子')

class School(object):
    '''定义学校类'''
    def __init__(self):
        '''
        初始化函数，默认使用的
        '''
        self.kongfu = ['学校煎饼果子配方']

    def make_cake(self):
        '''提供使用方法函数'''
        print(f'运用{self.kongfu}制作煎饼果子')


class Prentice(School, Master):
    '''继承学校和师傅的类'''
    def __init__(self):
        '''自创的初始化函数'''
        self.kongfu = '[自创的煎饼果子配方]'

    def make_cake(self):
        '''自创的方法函数'''
        self.__init__()  # 如果调用父类的属性及方法，需要初始化属性
        print(f'运用{self.kongfu}制作煎饼果子')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装。
    def make_master_cake(self):
        '''调用师傅的技术和方法，再次封装师傅的函数和方法'''
        Master.__init__(self)  # 初始化属性，因为上面用的自创技术。
        '''使用前都要初始化'''
        Master.make_cake(self)

    def make_School_cake(self):
        """
        调用培训的学习技术
        :rtype: object
        """
        School.__init__(self)  # 初始化属性，因为上面的自创技术。
        School.make_cake(self)
#
daqiu = Prentice()
daqiu.make_cake()   #自创的方式
daqiu.make_master_cake()  #调用师傅的技术和方法
daqiu.make_School_cake()  #调用学校的技术和方法
#########六、多层继承###############
父类-子类-子类
class Master(object):
    def __init__(self):
        self.kongfu = ['古法煎饼果子配方']

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

class School(object):
    def __init__(self):
        self.kongfu = ['学校煎饼果子配方']

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[自创的煎饼果子配方]'

    def make_cake(self):
        self.__init__()  # 如果调用父类的属性及方法，需要初始化属性
        print(f'运用{self.kongfu}制作煎饼果子')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装。
    def make_master_cake(self):
        '''调用师傅的技术和方法'''
        Master.__init__(self)  # 初始化属性，因为上面用的自创技术。
        Master.make_cake(self)

    def make_School_cake(self):
        """
调用培训的学习技术
        :rtype: object
        """
        School.__init__(self)  # 初始化属性，因为上面的自创技术。
        School.make_cake(self)

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


##创建徒孙类,用这个类创建对象。
class Tusun(Prentice):
    pass
#用这个类调用父类的属性或方法看看能否成功
xiaoqiu = Tusun()
print(xiaoqiu.kongfu)
xiaoqiu.make_cake()
xiaoqiu.make_master_cake()
xiaoqiu.make_School_cake()
# ###################七、super()调用父类的方法
class Master(object):
    def __init__(self):
        self.kongfu = ['古法煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

class School(Master):
    def __init__(self):
        self.kongfu = ['学校煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
      2.1  super（）带参数的写法
        super(School, self).__init__()
        super(School, self).make_cake()
        2.2无参数的super写法
        super().__init__()
        super().make_cake()
class Prentice(School):
    def __init__(self):
        self.kongfu = '[自创的煎饼果子配方]'
    def make_cake(self):
        self.__init__()  # 如果调用父类的属性及方法，需要初始化属性
        print(f'运用{self.kongfu}制作煎饼果子')
    def make_master_cake(self):
        '''调用师傅的技术和方法'''
        Master.__init__(self)  # 初始化属性，因为上面用的自创技术。
        Master.make_cake(self)

    def make_School_cake(self):
        """
        调用培训的学习技术
        :rtype: object
        """
        School.__init__(self)  # 初始化属性，因为上面的自创技术。
        School.make_cake(self)

    def make_old_cake(self):
        super().__init__()
        super().make_cake()
        School.__init__(self)
        School.make_cake(self)
        Master.__init__(self)
        Master.make_cake(self)
daqiu = Prentice()
daqiu.make_old_cake()
print(Prentice.__mro__)

# #####八。私有权限#############3
# 在PYthon中，可以实例化属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类
# 设置私有权限的方法：在属性名和方法名前面加上两个下划线__
class Master(object):
    def __init__(self):
        self.kongfu = ['古法煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
    def __init__(self):
        self.kongfu = ['学校煎饼果子技术']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = ['自创的煎饼果子配方']
        #定义私有属性，不继承
        self.__money = 20000
        #获取私有属性值
    def get__money(self):
        return self.__money
    def set__money(self):
        '''修改私有属性值'''
        self.__money = 500
        #定义私有方法
    def __info_print(self):
        print(self.kongfu)
        print('这是私有方法')

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_School_cake(self):
        School.__init__(self)
        School.make_cake(self)
    # def make_old_cake(self):
    #     super().__init__()
    #     super().make_cake()
class Tusun(Prentice):
    pass
daqiu = Prentice()
xiaoqiu = Tusun()
xiaoqiu.make_School_cake()
xiaoqiu.make_master_cake()
xiaoqiu.get__money()
print(xiaoqiu.get__money())
xiaoqiu.set__money()
xiaoqiu.get__money()  #两次调用值与上回不同的。
print(xiaoqiu.get__money())
###########继承总结###########33
继承的特点：
    子类默认拥有父类所有的属性及方法
    子类重写父类同名方法和属性
    子类调用父类同名方法和属性
super()方法快速调用父类方法
私有权限 __属性名 = 值
    不能继承给子类的属性和方法。需要添加私有权限
    语法。