python 面向对象之继承

文章目录

前言
继承的概念
单继承
多继承
子类重写父类的同名方法和属性
子类调用父类同名的方法和属性
多层继承
私有权限

前言

前面我们已经学习了 python 面向对象的类和对象，那么今天我将为大家分享面向对象的三大特性之一：继承。

继承具有以下特性：

代码重用：继承允许我们创建一个新的类，并从一个或多个现有的类中继承属性和方法。这使得我们可以避免重复编写相同的代码，提高代码的重用性。通过继承，我们可以在基类的基础上构建更特定和具体的子类。
扩展功能：通过继承，我们可以在基类的基础上添加新的属性和方法，以实现对基类功能的扩展。这样，我们可以在不修改基类代码的情况下，通过子类来定制或扩展特定的行为。这种灵活性使得我们能够轻松地适应不断变化的需求。
组织和抽象概念：通过继承，我们可以组织类之间的关系，并以更抽象的方式来表达概念和逻辑。通过将共同的属性和方法放在基类中，我们可以更清晰地表达类之间的关系和层次结构。这种抽象化的设计能够提高代码的可读性和可维护性。
实现多态性：继承也为实现多态性（Polymorphism）提供了基础。多态性是面向对象编程中非常重要的概念，它可以让我们使用统一的方式处理不同的对象类型。通过继承，我们可以创建不同的子类，它们共享相同的基类接口，但可能有不同的实现方式。这样，我们可以根据具体的对象类型来调用适当的方法，实现更灵活和可扩展的程序设计。

学习好了继承，可以为后面的抽象和多态打好基础，那么就由我带领大家走进 python 继承的世界吧。🚗🚗🚗

继承的概念

在生活中，继承通常是指子女继承父母的财产。但是在 python 中稍有区别，两个具有一定关系的子类和父类，子类会继承父类的所有除了私有的属性和方法。我们可以访问以及修改继承来的属性和方法。

在 python 中使用 class 子类名(父类名): 来表示继承关系。

class Animal():
    def __init__(self):
        self.info = '动物'

    def func(self):
        print(f'属于{self.info}')

class Cat(Animal):
    pass  # 这里pass是占位符，防止报错

cat = Cat()
cat.func()  # 属于动物

继承可以很大程度的提高代码的复用率，提高代码的简洁性。

在python中，其实每一个类都默认继承一个 object 基类

单继承

一个类可以只继承一个类，这种继承关系叫做单继承。

class Master():
    def __init__(self):
        self.wugong = '太极'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

class Prentice(Master):
    pass

zhangsan = Prentice()
zhangsan.func()  # 身怀绝技：太极

多继承

一个类也可以继承多个父类，这种继承关系叫做多继承。

class Master2():
    def __init__(self):
        self.wugong = '闪电五连鞭'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

class Prentice(Master1,Master2):
    pass

zhangsan = Prentice()
zhangsan.func()

当我们一个继承多个父类的时候，如果没有特地指明，默认使用第一个继承的父类的属性和方法。

如果我们想要查看该类的继承关系，我们可以使用 __mro__ 来查看继承关系。

print(Prentice.__mro__)

子类重写父类的同名方法和属性

子类继承父类的属性和方法，不可能原封不动的继承，子类也可以具有自己的特性。那么这里就需要用到重写的方法了。

class Master1():
    def __init__(self):
        self.wugong = '太极'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

class Master2():
    def __init__(self):
        self.wugong = '闪电五连鞭'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

class Prentice(Master1,Master2):
    def __init__(self):
        self.wugong = '太极+轻功'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

zhangsan = Prentice()
zhangsan.func()  # 身怀绝技：太极+轻功

子类调用父类同名的方法和属性

当我们在子类中调用和父类具有相同名字的属性和方法的时候，默认会调用子类具有的属性和方法。

class Master1():
    def __init__(self):
        self.wugong = '太极'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

class Master2():
    def __init__(self):
        self.wugong = '闪电五连鞭'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

class Prentice(Master1,Master2):
    def __init__(self):
        self.wugong = '火星大力拳'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

zhangsan = Prentice()
zhangsan.func()  # 身怀绝技：火星大力拳

那么如果我们要在父类中调用具有同名的父类的属性和方法该怎么做呢？

如果是先调用了父类的属性和方法，父类的属性和方法会覆盖子类的属性和方法，所以如果我们想要使用子类自己的属性和方法，需要调用子类自己的初始化方法。
如果我们想要在子类中调用父类的属性和方法，我们也需要先调用父类的初始化方法。

先调用父类的初始化方法，然后再使用 父类类名.方法(self) 来调用父类的方法。

class Master():
    def __init__(self):
        self.wugong = '太极'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

class Prentice(Master):
    def __init__(self):
        self.wugong = '闪电五连鞭'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

    def func1(self):
        Master.__init__(self)  # 调用父类的初始化方法
        Master.func(self)

    def func2(self):
        self.func()

zhangsan = Prentice()
zhangsan.func1()
zhangsan.func2()

当我们在子类中调用父类的初始化方法或者方法的时候，函数的参数列表必须加上 self ，否则就会报错。

当我们在子类中先调用父类的属性和方法的时候，再调用同名的子类自己的方法的时候，如果没有先调用子类自己的初始化方法，我们会发现会使用父类的属性和方法。

    def func2(self):
        self.__init__()
        self.func()
        
zhangsan = Prentice()
zhangsan.func1()
zhangsan.func2()

我们还可以使用 super() 来调用父类的方法和属性。但是这种 super() 只能调用子类的直接父类，不能调用简介的父类，如果想要调用简介父类，需要在直接父类的方法中使用 super()

super(当前类名,self).函数名

当然super里面的参数也可省略。

class Master():
    def __init__(self):
        self.wugong = '太极'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

class Prentice(Master):
    def __init__(self):
        self.wugong = '闪电五连鞭'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

    def func1(self):
        super().__init__()
        super().func()


zhangsan = Prentice()
zhangsan.func1()  # 身怀绝技：太极

使用 super() 后面的函数参数列表不需要条件self

多层继承

多层继承是指一个子类继承自另一个子类，而该子类又继承自另一个父类的情况。通过多层继承，可以在类之间形成层次结构，使得子类可以继承和重用祖先类的属性和方法。

# 定义基类A
class A:
    def method_A(self):
        print("This is method A")

# 定义中间类B，继承自基类A
class B(A):
    def method_B(self):
        print("This is method B")

# 定义子类C，继承自中间类B
class C(B):
    def method_C(self):
        print("This is method C")

在上述代码中，类A是基类，类B继承自基类A，类C继承自中间类B。这样，类C就拥有了自己的方法method_C，以及继承自类B和类A的方法method_B和method_A。

通过多层继承，实例化类C的对象，我们既可以调用method_C方法，也可以调用从类B和类A继承而来的方法：

obj = C()
obj.method_C()  # 调用C类的方法
obj.method_B()  # 调用B类的方法
obj.method_A()  # 调用A类的方法

This is method C
This is method B
This is method A

需要注意的是，在进行多层继承时，我们要谨慎选择继承关系，以避免出现复杂和难以维护的继承链。合理设计继承关系能够提高代码的可读性和可维护性，同时也要注意避免过度依赖继承，以免造成耦合性过高的问题。

私有权限

父类继承给子类，可以选择性的继承，可以选择有的东西不继承，这些不继承的事物可以被设置成私有权限，私有权限只能在当前类中访问和修改，就算是该类的子类也不能使用。

在 python 中，如果我们想设置私有权限，可以使用连个下划线来修饰方法名或者属性
__xx

class Master():
    def __init__(self):
        self.wugong = '太极'
        self.__name = 'lisi'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

class Prentice(Master):
    def __init__(self):
        self.wugong = '闪电五连鞭'

    def func(self):
        print(super().__name)  3 访问父类的私有权限



zhangsan = Prentice()
zhangsan.func()

我们不能访问和修改父类中的私有权限

但是呢，我们的父类可以提供接口来供子类或者其他类来获取和修改私有权限。

我们通常使用 get_xx 来获取私有权限值，set_xx 来修改私有权限值。

class Master():
    def __init__(self):
        self.wugong = '太极'
        self.__name = 'lisi'

    def func(self):
        print(f'身怀绝技：{self.wugong}')

    def get_name(self):
        return self.__name

    def set_name(self,name):
        self.__name = name

master = Master()
print(master.get_name())
master.set_name('wangwu')
print(master.get_name())