面向对象之继承

Myth丶恋晨 2022-01-11 04:25 391阅读 0赞

继承

单继承：一个类只继承一个父类
    抽离：先有多个有共同点的类，抽离出共性形成的类 => 父类
    派生：通过已有的父类，再去定义该类的子类，这种方式就叫做派生
    
    继承：继承是一种关系，子类可以通过父类获取属性和方法，能获取的根据就是继承
    
    继承的语法：
    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()

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() 查看继承顺序图

接口

接口：建立关联的桥梁，方便管理代码
    接口类：用来定义功能的类，为继承它的子类提供功能的，该类的功能方法一般不需要有实现体，实现体有继承它的子类自己去实现
    适合多继承，不需要实现体，不能够被实例化
    class PetInterface:
    def close_master(self):
    pass
    
    
    class WatchInterface:
    def watch_door(self):
    print('站着看门')
    
    
    class Dog(PetInterface, WatchInterface):
    def eat(self):
    print('吃东西')
    
    def run(self):
    print('跑')
    
    def jiao(self):
    print('叫')
    def watch_door(self):
    print('坐着看门')
    
    def close_master(self):
    print('亲密')
    
    
    dog = Dog()
    dog.eat()
    dog.watch_door()
    dog.close_master()

抽象父类

抽象父类：拥有抽象方法(子类共有的方法，但是父类不能有具体的实现体)的父类
    抽象方法：方法名是具体的，但是实现体是抽象的(在子类中重写来具象化)
    是一种单继承，可以拥有实现体
    注意点：有抽象方法的父类不能被实例化（假设能被实例化，就可以调用自己的抽象方法，没有任何意义）
    需要导入 abc
    import abc
    class Quan(metaclass=abc.ABCMeta):
    def __init__(self, name):
    self.name = name
    def run(self):
    print(self.name + 'running')
    
    @abc.abstractmethod
    def chi(self):
    pass
    
    @abc.abstractmethod
    def jiao(self):
    pass
    
    @classmethod
    @abc.abstractmethod
    def fn(cls): pass
    
    
    class Dog(Quan):
    @classmethod
    def fn(cls): pass
    
    def kanmen(self):
    print(self.name + '看门')
    
    def chi(self):
    super().chi()
    print(self.name + '狗粮')
    
    def jiao(self):
    print('汪汪汪')
    
    
    class Wolf(Quan):
    @classmethod
    def fn(cls): pass
    
    def bulie(self):
    print(self.name + '捕猎')
    
    def chi(self):
    print(self.name + '肉')
    
    def jiao(self):
    print('嗷嗷嗷')
    
    
    dog = Dog('来福')
    wolf = Wolf('常委')
    
    dog.jiao()

组合：自定义类的对象作为另外一个类的属性

class Teacher:
    def __init__(self, name, age):
    self.name = name
    self.age = age
    t1 = Teacher("Ben", 17)
    
    class Student:
    学生可以有 老师 属性
    def __init__(self, name, age, teacher):
    self.name = name
    self.age = age
    self.teacher = teacher # 组合
    stu = Student('Bob', 18, t1)
    
    访问老师具体的信息
    print(stu.teacher.name) #====>'Ben'
    print(stu.teacher.age) #====>17

转载于:https://www.cnblogs.com/wangtenghui/p/10816169.html