zoukankan      html  css  js  c++  java
  • 面向对象之继承

    什么是继承?
    继承指的是类与类之间的关系,是一种什么“是”什么的关系,继承的功能之一就是用来解决代码重用问题
    继承是一种创建新类的方式,在python中,新建的类可以继承一个或多个父类,父类又可以成为基类或超类,新建的类称为派生类或子类

    python中类的继承分为:单继承和多继承
    class ParentClass1: #定义父类
        pass

    class ParentClass2: #定义父类
        pass

    class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass
        pass

    class SubClass2(ParentClass1,ParentClass2): #python支持多继承,用逗号分隔开多个继承的类
        pass

    查看继承:
    SubClass1.__bases__

    经典类和新式类:
    Python2:类分为经典类和新式类
    经典类:没有继承object类的类
    新式类:继承object类的类
    Python3:只有新式类,创建的类若没有指定基类,默认继承object类

    继承和抽象:
    抽象:抽取类似或者比较像的部分
    抽象分为两个部分:
    1、将对象的相似部分抽取成类
    2、将类与类相似的部分抽取成父类
    继承:是基于抽象的结果,通过编程语言去实现它,肯定是先经历抽象这个过程,才能通过继承的方式去表达出抽象的结构。

    继承如何实现代码重用:
    在开发程序的过程中,如果我们定义了一个类A,然后又想新建立另外一个类B,但是类B的大部分内容与类A的相同时,我们不可能从头开始写一个类B,这就用到了类的继承的概念。
    通过继承的方式新建类B,让B继承A,B会‘遗传’A的所有属性(数据属性和函数属性),实现代码重用

    派生:
    子类也可以添加自己新的属性或者在自己这里重新定义这些属性(不会影响到父类),需要注意的是,一旦重新定义了自己的属性且与父类重名,那么调用新增的属性时,就以自己为准了。

    class Hero:
        def __init__(self, name, aggresivity, life_value):
            self.Aggresivity = aggresivity
            self.Name = name
            self.Life_value = life_value
    
        def attack(self, obj):
            obj.Life_value -= self.Aggresivity
            if obj.Life_value <= 0:
                print('%s 死亡' %obj.Name)
                return True
            else:
                print("%s被攻击, 生命值为:%s" %(obj.Name, obj.Life_value))
                return False
    
    class Gailun(Hero):
        def attack(self):
            print("我帅的一B!!!")
    
    g1 = Gailun('盖伦', 70, 100)
    g1.attack()
    # 打印结果:我帅的一B!!!



    继承的实现原理:
    python到底是如何实现继承的,对于你定义的每一个类,python会计算出一个方法解析顺序(MRO)列表,这个MRO列表就是一个简单的所有基类的线性顺序列表。
    为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

        子类会先于父类被检查
        多个父类会根据它们在列表中的顺序被检查
        如果对下一个类存在两个合法的选择,选择第一个父类

    Python中子类可以同时继承多个父类,如果继承了多个父类,那么属性的查找方式有两种,分别是:深度优先和广度优先

    经典类的查找方式为深度优先、新式类的查找方式为广度优先
    深度优先:一条路走到底后,在查找另一个父类
    A(B,C,D) ---> B(E) --->E(G)--->G--->C(F)--->F(G)--->D(G)
    广度优先
    A(B,C,D) ---> B(E) --->E(G)--->C(F)--->F(G)--->D(G)--->G
    示例:(Python3中)

    class A(object):
        def test(self):
            print('from A')
    
    class B(A):
        def test(self):
            print('from B')
    
    class C(A):
        def test(self):
            print('from C')
    
    class D(B):
        def test(self):
            print('from D')
    
    class E(C):
        def test(self):
            print('from E')
    
    class F(D,E):
        # def test(self):
        #     print('from F')
        pass
    
    f = F()
    f.text()
    print(F.__mro__) #只有新式才有这个属性可以查看线性列表,经典类没有这个属性
    
    查找方式
    F--->D--->B--->E--->C--->A



    在子类中调用父类的方法:
    1、指名道姓 不依赖继承关系
    2、super() 依赖继承关系
    一、指名道姓:

    class Hero:
        def __init__(self, name, aggresivity, life_value):
            self.Aggresivity = aggresivity
            self.Name = name
            self.Life_value = life_value
    
        def attack(self, obj):
            obj.Life_value -= self.Aggresivity
            if obj.Life_value <= 0:
                print('%s 死亡' %obj.Name)
                return True
            else:
                print("%s被攻击, 生命值为:%s" %(obj.Name, obj.Life_value))
                return False
    
    class Gailun(Hero):
        def attack(self, this_obj):
            Hero.attack(self, this_obj)
            print("我帅的一B!!!")
    
    class Ruiwen(Hero):
        pass
    
    
    g1 = Gailun("盖伦", 30, 100)
    r1 = Ruiwen("锐雯", 20, 100)
    
    g1.attack(r1)
    
    # 锐雯被攻击, 生命值为:70
    # 我帅的一B!!!

    父类的属性中有多少个参数,在子类调用的时候就要传递多少个参数

    二、super():

    class Hero:
        def __init__(self, name, aggresivity, life_value):
            self.Aggresivity = aggresivity
            self.Name = name
            self.Life_value = life_value
    
        def attack(self, obj):
            obj.Life_value -= self.Aggresivity
            if obj.Life_value <= 0:
                print('%s 死亡' %obj.Name)
                return True
            else:
                print("%s被攻击, 生命值为:%s" %(obj.Name, obj.Life_value))
                return False
    
    class Gailun(Hero):
    
    
        def __init__(self, name, aggresivity, life_value, weapon):
            super().__init__(name, aggresivity, life_value)
            self.Weapon = weapon
    
    
        def attack(self, this_obj):
            Hero.attack(self, this_obj)
            print("我帅的一B!!!")
    
    
    g1 = Gailun("盖伦", 30, 100, '')
    print(g1.__dict__)
    # {'Aggresivity': 30, 'Name': '盖伦', 'Life_value': 100, 'Weapon': '刀'}

    在调用父类__init__方法时,super()可以不用传递子类名和self。

    class A:
        def f1(self):
            print('from A')
            super().f1()
    
    
    class B:
        def f1(self):
            print('from B')
    
    class C(A,B):
        pass
    
    
    # print(C.mro())
    # [<class '__main__.C'>,
    # <class '__main__.A'>,
    # <class '__main__.B'>,
    # <class 'object'>]
    
    
    c=C()
    c.f1()
    # from A
    # from B

    super()依照的是mro列表的

    组合:

     组合的方式
    用组合的方式建立了类与组合的类之间的关系,它是一种‘有’的关系,比如教授有生日,教授教python和linux课程,教授有学生stu1、stu2、stu3

    class People:
        def __init__(self,name,age,sex):
            self.name=name
            self.age=age
            self.sex=sex
    
    class Course:
        def __init__(self,name,period,price):
            self.name=name
            self.period=period
            self.price=price
        def tell_info(self):
            print('<%s %s %s>' %(self.name,self.period,self.price))
    
    class Teacher(People):
        def __init__(self,name,age,sex,job_title):
            People.__init__(self,name,age,sex)
            self.job_title=job_title
            self.course=[]
            self.students=[]
    
    
    class Student(People):
        def __init__(self,name,age,sex):
            People.__init__(self,name,age,sex)
            self.course=[]
    
    
    egon=Teacher('egon',18,'male','沙河霸道金牌讲师')
    s1=Student('牛榴弹',18,'female')
    
    python=Course('python','3mons',3000.0)
    linux=Course('python','3mons',3000.0)
    
    #为老师egon和学生s1添加课程
    egon.course.append(python)
    egon.course.append(linux)
    s1.course.append(python)
    
    #为老师egon添加学生s1
    egon.students.append(s1)

    for obj in egon.course:
        obj.tell_info()

    当类之间有显著不同,并且较小的类是较大的类所需要的组件时,用组合比较好。

    抽象类:

    1 什么是抽象类

    与java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化

    2 为什么要有抽象类

    如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类就是从一堆类中抽取相同的内容而来的,内容包括数据属性和函数属性。

      比如我们有香蕉的类,有苹果的类,有桃子的类,从这些类抽取相同的内容就是水果这个抽象的类,你吃水果时,要么是吃一个具体的香蕉,要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。

    从设计角度去看,如果类是从现实对象抽象而来的,那么抽象类就是基于类抽象而来的。

      从实现角度来看,抽象类与普通类的不同之处在于:抽象类中只能有抽象方法(没有实现功能),该类不能被实例化,只能被继承,且子类必须实现抽象方法。这一点与接口有点类似,但其实是不同的。

    import abc
    class Animals(metaclass = ABCMeta):
    
        @abc.abstractmethod    #定义抽象方法,无需实现功能
        def walk(self):
            pass
        
        @abc.abstactmethod    #定义抽象方法,无需实现功能
        def sleep(self):
            pass
    
    class People(Animals):
        
        def walk(self)   # 必须定义此方法
            print("is walking")
     
        def sleep(self)  # 必须定义此方法
            print("is sleeping")
  • 相关阅读:
    POJ3693 Maximum repetition substring —— 后缀数组 重复次数最多的连续重复子串
    SPOJ
    POJ2774 Long Long Message —— 后缀数组 两字符串的最长公共子串
    POJ3261 Milk Patterns —— 后缀数组 出现k次且可重叠的最长子串
    POJ1743 Musical Theme —— 后缀数组 重复出现且不重叠的最长子串
    SPOJ
    AC自动机小结
    HDU3247 Resource Archiver —— AC自动机 + BFS最短路 + 状压DP
    POJ1625 Censored! —— AC自动机 + DP + 大数
    Herding
  • 原文地址:https://www.cnblogs.com/zrxu/p/11609451.html
Copyright © 2011-2022 走看看