面向对象的三大特性之继承

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

# 抽离：先有多个有共同点的类，抽离出共性造成的类 => 父类
# 派生：经过已有的父类，再去定义该类的子类，这种方式就叫作派生

# 继承：继承是一种关系，子类能够经过父类获取属性和方法，能获取的根据就是继承

# 继承的语法：
# class 父类名:pass
# class 子类名(父类名): pass
class Sup:
pass
class Sub(Sup):
   pass

   # 继承的规则
# 1.父类的全部未封装的属性和方法，子类都能访问
# 2.父类的全部封装的属性和方法，子类都不能访问
#       -- 在外界经过子类或子类对象，不能访问
#       -- 在子类内部经过子类或子类对象也不能访问

class Sup:
__num = 10  # 封装被改名为_Sup__num
class Sub(Sup):
   def test(self):
  print(self.__num)  # 本质去访问_Sub__num，因此不能访问
      
    # 继承父类的方法：子类没有明文书写父类的方法，经过继承关系拿到
    class Sup:
def test(self):
  print(self)  # 父类对象调用就是父类对象，子类对象调用就是当前调用的子类对象
      
    class Sub(Sup):
    pass
Sub().test()
   
# 重写父类的方法：子类明文书写父类同名的方法，而且实现体自定义
class Sup:
def test(self):
  print(self)  # 父类对象调用就是父类对象，子类对象调用就是当前调用的子类对象
      
    class Sub(Sup):
    def test(self):
  print('本身的方法', self)
   Sub().test()
    
# 重用父类的方法：子类明文书写父类同名的方法，有本身的实现体，但也用父类原有的功能
class Sup:
def test(self):
  print(self)  # 父类对象调用就是父类对象，子类对象调用就是当前调用的子类对象
      
    class Sub(Sup):
    def test(self):
  super().test()  # 本质 super(Sub, self).test() py2必须这么写
      print('本身的方法', self)
    Sub().test()

了解：重用概念

# java中存在方法的重用
def fn():
pass
def fn(num):
   pass
# fn()调用不传参调用第一个fn
   # fn(10)调用传入一个参数调用第二个fn

super关键字

class Sup:
def __init__(self, name):
  self.name = name
   
    def test(self):
      print(self)
   
    
class Sub(Sup):
# 默认父级的__init__能够被继承过来，
# 可是会出现子类对象的属性比父类多
   def __init__(self, name, salary):
      super().__init__(name)  # 父级有的共性功能经过super()交给父级作
      self.salary = salary  # 子类特有的本身来完成
    
    # 有继承关系下，只要名字相同，即便参数不一样，仍是属于同一个方法
   def test(self, num):
      super().test()  # 使用父级的方法
      print(num)
       
    # 外界经过Sub对象来调用test方法，必定找本身的test方法(属性的查找顺序)
    

   # 重点：super() 能够获得调用父级功能的对象，调用者仍是子类对象
#      -- super()只能在子类的方法中使用
#      -- super()本质 super(子类类名, 当前对象)
#      -- super().父类普通方法 | super().__init__() | super()能调用父类全部可继承方法

多继承

# 属性的查找顺序：优先找本身的，若是没有，按照继承前后查找父级
class A:
name = 'A'
num = 10
   
   class B:
name = 'B'
count = 100
   
   # 子类能够继承全部父类的全部可继承属性
class C(A, B):  # 本身 => A => B
# name = 'C'
pass

复杂多继承

class A:
name = "A"
class B(A):
   name = "B"
class C:
   name = "C"
class D(C):
   name = "D"
class E(B, D):  # 先将B的全部父级们找完再找D的分支
   name = "E"
print(E.mro())  # E => B => A => D => C

菱形继承

# 经典类：python2中才有，没有继承任何类的类 - 深度优先
# 新式类：python2中直接或间接继承object的类，python中所定义的全部类 - 广度优先

# 深度优先，在查找第一个分支是就将菱形的头查找了
# 广度优先，菱形的头在全部分支查找接收后再被查找

# 经过 类.mro() 查看继承顺序图

总结

'''
继承

1.父类：在类后()中写父类们
class A:pass
class B:pass
class C(A, B):pass

2.属性查找顺序：本身 -> ()左侧的父类 -> 依次往右类推

3.抽离：先定义子类，由子类的共性抽离出父类 - 派生：父类已经建立，经过父类再去派生子类

4.继承关系
  -- 1）父类的全部非封装的属性和方法均能被继承
  -- 2）父类的全部封装的属性和方法均能被继承
  -- 3）在子类中要去使用父类的方法
      -- 子类继承父类方法：子类不须要去实现父类的方法，子类对象能够直接调用父类方法
      -- 重写父类的方法：方法名与父类相同，实现体与父类不一样，子类对象调用的是自身方法
      -- 重用父类的方法：方法名与父类相同，实现体中有本身的逻辑也调用了父类的方法(super())
          -- super():在子类中获取能够调用父类方法的对象，且在父类中体现的调用者子类或子类对象
      
5.复杂继承：一个类能够继承多个类，查找顺序是根据继承父类从左往右的顺序，而且在查找第一个父类时，将父类的父类也进行查找(一个父类分支所有查找完毕才去查找下一个父类分支)  

6.棱形继承
  -- 经典类：py2中类不默认继承object，因此没有明确继承的类就没有继承任何类，这样的类称之为经典类
  -- 新式类：全部直接或间接继承object的类，py2中主动继承object的类及py3中全部的类
  
  -- 前提：父类中有共有属性或方法，子类没有本身去定义这些属性和方法，必须从父类中获取，到底从哪一个父类中获取
  -- 经典类：深度查找 a -> b -> d -> c
  -- 新式类：广度优先 a -> b -> c -> d
  d
b      c
  a
'''