13 python面向对象：继承、重写、super、多重继承、多态

一、继承简介

• 继承是面向对象三大特性之一
• 通过继承我们可以使一个类获取到其他类中的属性和方法
• 在定义类时，可以在类名后面的括号中指定当前类的父类(超类、基类)
• 继承提高了类的复用性。让类与类之间产生了关系。有了这个关系，才有了多态的特性
• 在创建类的时候，如果省略了父类，则默认父类是object
• object是所有类的父类，所有类都继承与object

class Animal:
    def run(self):
        print('动物会跑.......')
    def sleep(self):
        print('动物睡觉......')
class NewDog(Animal):
    def run(self):
        print('狗会跑.......')
    def sleep(self):
        print('狗睡觉......')
    def speak(self):
        print("汪汪汪......")
d=Dog()
r=isinstance(d,Dog)
print(r)    # True
r=isinstance(d,animal)
print(r)    # True

# issubclass()  检测一个类是否是另一个类的子类
print(issubclass(Dog,Animal)) # True
print(issubclass(Dog,object)) # True
print(issubclass(Animal,object)) # True
print(issubclass(int,object)) # True

二、类的方法重写

• 如果在子类中有和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点我们称之为方法的重写(覆盖)
• 当我们调用一个对象的方法时：
  • 会优先去当前对象中寻找是否具有该方法，如果有则直接调用
  • 如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
  • 如果没有，则去父类中的父类寻找，以此类推，直到找到object，如果依 然没有找到就报错了

class A(object):
    def test(self):
        print('A.........')

class B(A):
    pass

class C(B):
    pass

c = C()
c.test()
# A.........

class A(object):
    def test(self):
        print('A.........')

class B(A):
    def test(self):
        print('B.........')

class C(B):
    pass

c = C()
c.test()
# B.........

class A(object):
    def test(self):
        print('A.........')

class B(A):
    def test(self):
        print('B.........')

class C(B):
    def test(self):
        print('C.........')

c = C()
c.test()
# c.speak()               # AttributeError: 'C' object has no attribute 'speak'
# C.........

三、super()

• 父类的所有方法都会被子类继承，
• super()可以获取当前类的父类 并且通过super()返回对象调用父类方法时，不需要传递self
• 调用方法：
  • super.特殊方法（）
  • super(类名，self).普通方法（）

class Animal:
    def __init__(self,name):
        self._name=name
    def run(self):
        print('动物会跑.......')
    def sleep(self):
        print('动物睡觉......')
    @property
    def name(self):
        return  self._name
    @name.setter
    def name(self,name):
        self._name=name

class Dog(Animal):
    def __init__(self,name,age):
        # self._name = name
        # Animal.__init__(self,name)	#父类名调用
        super().__init__(name)			#super调用						
        self._age=age
    def run(self):
        Animal.run(self)         		# 父类名调用
        super(Dog, self).run()			# super调用			
        print('狗会跑.......')
    def sleep(self):
        print('我会看家......')
    @property
    def age(self):
        return self._age
    @age.setter
    def age(self, age):
        self._age = age

四、多重继承

• 在Python中是支持多重继承的。也就是我们可以为一个类同时制定多个父类
• 可以在类名的()后边添加多个类，来实现多重继承
• 多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
• 在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
• 如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二 个，找第三个…前面会覆盖后面的

__ bases__: 可以获取当前类所有的父类

• 返回当前类的多个父类，返回是元组类型值，

class A(object):
    def test(self):
        print("A......")
    def test1(self):
        print("A-test1......")
    def test3(self):
        print("A-test3......")

class B(object):
    def test(self):
        print("B......")
    def test2(self):
        print("B-test2......")
class C(B,A):
    pass
            
print(C.__bases__)
# (<class '__main__.A'>, <class '__main__.B'>)
  
c= C()
c.test()		# B......
c.test1()		# A-test1......
c.test2()		# B-test2......
c.test3()		# A-test3......

五、多态

• 多态是面向对象的三大特性之一。从字面理解就是多种形态
• 一个对象可以以不同形态去呈现
• 面向对象三大特性
  • 封装：确保对象中数据的安全
  • 继承：保证了对象的扩展性
  • 多态：保证了程序的灵活性

len() 返回变量长度

• 定义变量的对象中有个这个__len__特殊方法就可以使用len()函数来获取长度

class A:
    def __init__(self,name):
        self._name = name
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self, name):
        self._name = name

class B:
    def __init__(self, name):
        self._name = name
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self, name):
        self._name = name

a = A('葫芦娃')
b = B('黑猫警长')

def speak(obj):
    print('你好%s'%obj.name)

speak(a)
speak(b)
# 你好葫芦娃
# 你好黑猫警长


lst=[1,2,3,4]
str="python"

print(len(lst))     # 4
print(len(str))     # 6
# print(len(a)) # TypeError: object of type 'A' has no len()

class A:
  def __len__():
  	return 100
a=A()
print(len(a))		# 100

a= 10
b= True
# print(len(a))           # TypeError: object of type 'int' has no len()
# print(len(b))           # TypeError: object of type 'bool' has no len()         

总结：面向对象三大特性

• 封装 确保对象中的数据安全
• 继承 保证了对象的可拓展性
• 多态 保证了程序的灵活性