面向对象（二）

程序中的继承
在程序中，继承描述的是多个类之间的所属关系。
如果一个类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()

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

# 父类
class jqr(object):
    def __init__(self):
        self.s = "机器人"
    def f(self):
        print("这是一个完美的<%s>" % self.s)
class SC(jqr):
    pass
c = jqr()
print(c.s)
c.f()

说明：
虽然子类没有定义__init__方法初始化属性，也没有定义实例方法，但是父类有。所以只要创建子类的对象，就默认执行了那个继承过来的__init__方法
总结：
子类在继承的时候，在定义类时，小括号()中为父类的名字
父类的属性、方法，会被继承给子类

多继承：子类继承多个父类

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()

案例1：

案例2：

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(Master, School):  # 多继承，继承了多个父类（Master在前）
    pass

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

说明： 多继承可以继承多个父类，也继承了所有父类的属性和方法
注意：
如果多个父类中有同名的属性和方法，则默认使用第一个父类的属性和方法（根据类的魔法属性mro的顺序来查找）
多个父类中，不重名的属性和方法，不会有任何影响。

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(Master, School):  # 多继承，继承了多个父类（Master在前）
    pass

damao = Prentice()
print(damao.kongfu) # 执行Master的属性
damao.make_cake() # 执行Master的实例方法
# 子类的魔法属性__mro__决定了属性和方法的查找顺序
print(Prentice.__mro__)

# 父类
class A(object):
    def __init__(self):
        self.car='20款奔驰'
    def print_car(self):
        print('老款%s'%self.car)

class B(object):
    def __init__(self):
        self.car='21款背驰'
    def print_car(self):
        print('新款%s'%self.car)
# 子类
class C(B,A):
    def __init__(self):
        self.car='22款奔驰'
    def print_car(self):
        print('执行子类的__init__方法前，self.car的属性：%s'%self.car)
        self.__init__() # 执行本类的__init__方法，属性初始化
        print('执行子类的__init__方法前，self.car的属性：%s' % self.car)
        print('最新款%s'%self.car)
    def print_lao_car(self):
        print('执行A的__init__方法前，self.car的属性：%s' % self.car)
        A.__init__(self)  # 执行本类的__init__方法，属性初始化
        print('执行A的__init__方法前，self.car的属性：%s' % self.car)
        A.print_car(self)
    def print_xin_car(self):
        print('执行B的__init__方法前，self.car的属性：%s' % self.car)
        B.__init__(self)  # 执行本类的__init__方法，属性初始化
        print('执行B的__init__方法前，self.car的属性：%s' % self.car)
        B.print_car(self)

c=C()
c.print_car()
print('*'*10)
c.print_lao_car()
print('*'*10)
c.print_xin_car()
print('*'*10)
c.print_car()

class A(object):
    def __init__(self):
        self.car='20款奔驰'
    def print_car(self):
        print('老款%s'%self.car)
class B(object):
    def __init__(self):
        self.car='21款奔驰'
    def print_car(self):
        print('新款%s'%self.car)
class C(B,A):
    def __init__(self):
        self.car='22款奔驰'
        self.money=40
    def print_car(self):
        self.__init__()
        print('最新款%s'%self.car)
    def print_lao_car(self):
        A.__init__(self)  # 执行A类的__init__方法，属性初始化
        A.print_car(self)
    def print_xin_car(self):
        B.__init__(self)  # 执行B类的__init__方法，属性初始化
        B.print_car(self)
class D(C): # 多层继承
    pass
d=D()
d.print_car()
d.print_lao_car()
d.print_xin_car()

class Animal(object):
    def play(self):
        print("动物都有各自的玩法")
class Cat(Animal):
# 方法的重写/覆盖
    def play(self):
        super().play()
        print("猫喜欢玩球")
c = Cat()
c.play()

class Gupiao(object):
    def xinqing(self):
        print('股票买入和卖出')

class Gongmu(Gupiao):
    def lianghua(self):
        super().xinqing()
        print('公募机构买入和卖出')

class Simu(Gupiao):
    def lianghua(self):
        Gupiao.__init__(self)
        Gupiao.xinqing(self)
        print('私募机构买入和卖出')

    def xinqing(self):
        print('专研自己的输出股票和私募买入和卖出')

g=Gongmu()
g.lianghua()
print('*'*10)
s=Simu()
s.lianghua()
s.xinqing()