Python面向对象之继承

面向对象三大特性

1. 封装 根据职责将属性和方法封装到一个抽象的类中；
2. 继承 实现代码的重用，西安通的代码不需要重复的编写；
3. 多态 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度。

单继承

使用继承前的代码

class Animal:
    def eat(self):
        print("吃")

    def sleep(self):
        print("睡")


class Dog:
    def eat(self):
        print("吃")

    def sleep(self):
        print("睡")

    def bark(self):
        print("犬吠")


dog = Animal()
dog.eat()
dog.sleep()

jinmao = Dog()
jinmao.eat()
jinmao.bark()

虽然可以通过代码复制来减少工作量，但代码重复却很多。

继承的概念和语法

继承的概念：子类拥有父类所有的属性和方法；

继承的语法

class 类名(父类名)：
	pass

• 子类继承自父类，可以直接享用父类中已经开发好的方法，不需要再次开发；
• 子类中应该根据职责，封装子类中特有的属性和方法；

单继承示例

class Animal:
    def eat(self):
        print("吃")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")


class Dog(Animal):
    def bark(self):
        print("犬吠")


jinmao = Dog()
jinmao.eat()  # 吃
jinmao.bark()  # 叫

继承相关术语

子类=派生类；
父类=基类；
继承=派生；

例如：
Dog类是Animal类的子类，Animal类是Dog类的父类，Dog类从Animal类继承；

继承的传递性

• C类继承自B类，B类又继承自A类；
• 那么C类就拥有B类和A类所有的属性和方法；
• 总结就是：子类拥有父类及父类的父类的所有封装的属性与方法。

继承传递示例

class Animal:
    def eat(self):
        print("吃")

    def run(self):
        print("跑")


class Dog(Animal):
    def bark(self):
        print("犬吠")


class Corgi(Dog):
    def leg(self):
        print("腿很短")


keji = Corgi()
# 子类使用自己的方法
keji.leg()
# 子类使用父类的方法
keji.bark()
# 子类使用父类的父类的方法
keji.eat()

继承传递的分支问题

虽然猫和狗都继承自动物类，但狗的子类柯基并不能调用猫类的方法，因为柯基并没有继承自猫类；

方法重写

应用场景

• 当父类中的方法满足不了子类的需求时，可以对方法进行重写；
• 重写父类的方法有两种：
  1.覆盖父类的方法；
  2.对父类方法进行扩展；

覆盖父类的方法

如果在开发中，父类的方法实现和子类的方法实现，完全不同，就可以使用覆盖在方法，在子类中重新编写父类的方法实现；

覆盖方式：在子类中定义一个和父类重名的方法并且实现；

重写之后，在运行时，只会调用子类中重写的方法，而不会再调用父类中封装的方法；

class Dog(Animal):
    def bark(self):
        print("犬吠")


class Corgi(Dog):
    def leg(self):
        print("腿很短")
        
    def bark(self):
        print("柯基吠")


keji = Corgi()
# 子类使用自己的方法
keji.leg()
# 子类使用重写父类的方法
keji.bark()

子类中扩写父类的方法

如果在开发中，子类的方法实现，包含了父类的方法实现，即原本父类封装的方法是子类方法的一部分，这时候就可以使用子类扩写父类的方法。

扩写方式：

1. 在子类中重写父类的方法；
2. 在需要的位置，调用父类的方法，用super().父类方法名
3. 编写子类方法其他的代码

关于super

1. 在python中，super是一个特殊的类；
2. super()就是使用super类创建出来的对象；
3. 经常使用的场景就是，重写父类方法时，调用在父类中封装的方法；

扩写示例

class Dog(Animal):
    def bark(self):
        print("犬吠")


class Corgi(Dog):
    def leg(self):
        print("腿很短")

    def bark(self):
        # 1.针对子类特有的需求，编写代码
        print("柯基吠")
        # 2.在需要的位置，调用父类的方法，用super().父类方法名
        super().bark()
        # 3.编写子类方法其他的代码
        print("...")


keji = Corgi()
# 子类使用自己的方法
keji.leg()
# 子类使用 扩展父类的方法
keji.bark()

# 腿很短
# 柯基吠
# 犬吠
# ...

使用父类名调用父类方法(了解)

在python2.x中，如果需要调用父类的方法，还可以用这种方式：

父类名.方法(self)

在python3中，仍然支持这种方法，但不推荐使用，因为一旦父类发生变化，调用位置的父类名同样需要修改

注意：

1. 在开发中，父类名和super()两种方法不要混用；
2. 如果使用当前子类名调用方法，会形成递归调用，形成死循环；

使用父类名调用父类方法示例

class Dog(Animal):
    def bark(self):
        print("犬吠")


class Corgi(Dog):
    def leg(self):
        print("腿很短")

    def bark(self):
        print("柯基吠")
        # 使用父类名调用父类方法，不推荐使用
        Dog.bark(self)
        # 注意，如果使用子类调用方法，会出现递归调用，形成死循环
        # Corgi.bark(self)
        
        print("...")


keji = Corgi()
keji.leg()
keji.bark()

# 腿很短
# 柯基吠
# 犬吠
# ...

多继承

多继承概念和语法

概念：子类可以具有多个父类，并且具有多个父类的属性和方法；

语法：

class 子类名(父类1，父类2，...):
	pass

作用：多继承可以让子类同时具有多个父类的属性和方法；

多继承示例

class A:
    def test_a(self):
        print("test_a")


class B:
    def test_b(self):
        print("test_b")


class C(A, B):
    pass


c = C()

c.test_a()  # test_a
c.test_b()  # test_b

多继承注意事项

• 如果两个父类之间具有同名属性或方法，应该尽量避免使用多继承；
• 如果两个父类之间具有同名属性或方法，子类在调用方法时，会优先使用先继承那个父类的方法；

多继承方法调用顺序示例

class A:
    def test(self):
        print("test_a")

    def demo(self):
        print("demo_a")


class B:
    def test(self):
        print("test_b")

    def demo(self):
        print("demo_b")


class C(A, B):
    pass


c = C()

c.test()  # test_a
c.demo()  # demo_a

我们把C的继承父类顺序换一下

class A:
    def test(self):
        print("test_a")

    def demo(self):
        print("demo_a")


class B:
    def test(self):
        print("test_b")

    def demo(self):
        print("demo_b")


class C(B, A):
    pass


c = C()

c.test()  # test_b
c.demo()  # demo_b

MRO--方法搜索顺序

__mro__的作用：在创建对象的类，以及继承的父类中，查找要调用的方法的 顺序；

• python中针对类提供了一个内置属性__mro__可以查看方法搜索顺序；
• mro主要用于多继承时，判断方法，属性的调用顺序；

__mro__方法使用示例

# 假设C类继承自B和A
print(C.__mro__)
输出结果：
# (<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

• 在搜索方法时，是按照__mro__搜索结果从左到右的顺序查找的；
• 如果在当前类中找到方法，就直接执行，不再查找；
• 如果没有找到，就查找下一个类中是否有对应的方法，如果找到方法，就直接执行，不再查找；
• 如果找到最后一个类，还没有找到方法，就报错。

__mro__方法使用完整示例

class A:
    def test(self):
        print("test_a")

    def demo(self):
        print("demo_a")


class B:
    def test(self):
        print("test_b")

    def demo(self):
        print("demo_b")


class C(B, A):
    pass


c = C()

c.test()  # test_b
c.demo()  # demo_b

# 确定C类的调用方法顺序
print(C.__mro__)  # (<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

新式类和经典(旧式)类

• 在ipython中，添加了object就是新式类，没添加就是经典类；可以用dir(对象名)查看新式类和经典类的内置方法；
• 在ipython3下，就算你没添加object，python解释器也会给你加上，默认就是新式类；

object是python为所有对象提供的基类，提供有一些内置的方法和属性，可以用dir函数查看，dir(对象名);

新式类：以object为基类的类，推荐使用；
经典类：不以object为基类的类，不推荐使用；

• 在python3中定义类时，如果没有指定父类，会默认使用object作为该类的基类--python3中定义的类都是新式类；
• 在python2中，定义类时，如果没有指定父类，则不会以object作为基类；
  新式类和经典类在多继承时，会影响方法的搜索顺序；

为了保证编写的代码能同时在python2和python3下运行，以后在定义类时，如果没有父类，建议统一继承object类；

class 类名(object):
	pass

在ipython下查看内置方法

查看新式类内置方法

class A(object):
	pass

a = A()
dir(a)

查看旧式类内置方法

class B:
	pass

b = B()
dir(b)