python之多态、继承、重写篇（python继承多态封装）

# -*- coding: UTF-8 -*-
class Animal:
    def run(self):
        print("动物会跑。。")

    def sleep(self):
        print('动物会睡觉')

class Dog:
    def run(self):
        print("狗会跑。。")

    def sleep(self):
        print('狗会睡觉')

    def bark(self):
        print('狗会叫')

#如果在子类中如果有和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法而不是父类的方法，这个特地我们称为重写（覆盖）
d = Dog()
d.run()

#当我们调用一个对象的方法时，会优先去当前对象中寻找是否具有该方法，如果有则直接调用，
#如果没有，则去当前的父类中寻找，如果父类中有则直接调用父类中的方法
#如果没有，则去父类中寻找，以此类推，直到找到object，如果依然没有找到，则报错。
class A(object):
    def test(self):
        print('AAA')

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

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

c = C()
c.test()

# -*- coding: UTF-8 -*-
#多态面向对象的三大特征之一
#多态从字面上理解是多种形态
#狗（狼狗，哈士奇。。。）
#一个对象可以以不同的形态去呈现


#定义两个类
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

    def __len__(self):
        pass


    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name

class C():
    pass

a = A('孙悟空')
b = B('猪八戒')
c = C()

#定义一个函数
#对于say_hello()这个函数来说，只要对象中含有name属性，他就可以作为参数传递。
#这个函数并不会考虑对象的类型，只要name属性就可以了
def say_hello(obj):
    print('你好 %s' % obj.name)

#在say_hello_2中我们做了一个类型检查，也就是只有obj是A类型的对象时，才可以正常使用，
#其他类型的对象都无法使用该函数，这个函数就违反了多态
#违反了多态的函数，只适用于一种类的对象，无法处理其他类的对象，这样导致函数的适应性非常差。
#
def say_hello_2(obj):
    if isinstance(obj, A):
        print('你好 %s' % obj.name)
say_hello(b)
say_hello_2(b)

#鸭子类型
#如果一个东西走路像鸭，叫声像鸭，那么他就是鸭子。

#len()
#之所以一个对象能用len()来获取长度，是因为对象中具有一个特殊的方法__len__
l = [1, 2, 3]
s = 'hello'
print(len(l))
print(len(s))

#面向对象的三大特征
#封装：确保对象的数据安全性
#继承：确保了对象的可扩展性
#多态：确保程序的灵活性。

# -*- coding: UTF-8 -*-
class A(object):
    def test(self):
        print('AAA')

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

#在python中支持多重继承，也就是我们可以为一个类同时指定多个父类
#可以在类名的()后边添加多个类，来实现多重继承
#多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
#在开发中如果没有特殊情况，尽量避免使用多重继承，多重继承会使我们代码更加复杂
#如果多个父类中有同名的方法，会先从第一个父类中查找，然后再找第二个，第三个。。，前边父类方法会覆盖后面的父类方法
class C(A, B):
    pass

#类名.__bases__这个属性用来获取当前类的所有父类
print(C.__bases__) #(<class '__main__.B'>,)
print(B.__bases__) #(<class '__main__.A'>,)

print(C.__bases__)

# -*- coding: UTF-8 -*-
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:
    def __init__(self, name, age):
        #希望可以直接调用父类的__init__来初始化父类中定义的属性
        #super()可以用来获取当前类的父类
        #并且通过super()返回对象调用父类方法时，不需要传递self
        super().__init__(name)
        self._age = age

    def run(self):
        print("狗会跑。。")

    def sleep(self):
        print('狗会睡觉')

    def bark(self):
        print('狗会叫')

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age