24 类：组合 继承 super关键字 面向对象的三大性

时间：2022-07-13 09:04:37

组合

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

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)

print(stu.teacher.age)

继承

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

抽离：先定义子类，由子类的共性抽离出父类
派生：父类已经创建，通过父类再去派生子类

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

继承的语法：

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，所以不能访问

1. 继承父类的方法：

子类没有明文书写父类的方法，通过继承关系拿到
子类不需要去实现父类的方法，子类对象可以直接调用父类方法

class Sup:

    def test(self):

        print(self)  # 父类对象调用就是父类对象，子类对象调用就是当前调用的子类对象

class Sub(Sup):

    pass

Sub().test()

2. 重写父类的方法：

子类方法名与父类相同，实现体与父类不同，子类对象调用的是自身方法

class Sup:

    def test(self):

        print(self)  # 父类对象调用就是父类对象，子类对象调用就是当前调用的子类对象

class Sub(Sup):

    def test(self):

        print('自己的方法', self)

Sub().test()

3. 重用父类的方法：

子类方法名与父类相同，实现体中有自己的逻辑也调用了父类的方法(super())

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：方法的重用

# java中存在方法的重用

def fn():

    pass

def fn(num):

    pass

# fn()调用不传参调用第一个fn

# fn(10)调用传入一个参数调用第二个fn

了解：重用概念

super关键字

super() 可以得到调用父级功能的对象，调用者还是子类对象
   -- super()只能在子类的方法中使用
   -- super()本质 super(子类类名, 当前对象)
   -- super().父类普通方法 | super().__init__() | 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方法(属性的查找顺序)

2）多继承

属性的查找顺序：优先找自己的，如果没有，按照继承先后查找父级

class A:

    name = 'A'

    num = 10

class B:

    name = 'B'

    count = 100

# 子类可以继承所有父类的所有可继承属性

class C(A, B):  # 自己 => A => B

    # name = 'C'

    pass

3）复杂多继承

一个类可以继承多个类，查找顺序是根据继承父类从左往右的顺序，
并且在查找每一个父类时，将父类的父类也进行查找(一个父类分支全部查找完毕再查找下一个父类分支)

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

4）菱形继承

父类中有共有属性或方法，子类没有自己去定义这些属性和方法，必须从父类中获取，到底从哪个父类中获取

经典类：py2中类不默认继承object，所以没有明确继承的类就没有继承任何类，这样的类称之为经典类
新式类：所有直接或间接继承object的类，py2中主动继承object的类及py3中所有的类
　　　　Python3中，通过 类名.mro() 查看继承顺序

-- 经典类：深度查找 a -> b -> d -> c
 -- 新式类：广度优先 a -> b -> c -> d

/ d \
 b(d)       c(d)
    \ a(b,c) /

面向对象的三大特性

封装：隐藏细节 - 抽离共有
继承：
多态：

相关文章