抽象类和多态

一、抽象类

抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化
从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的。

# 导入abc模块实现抽象类
import abc

# 定义抽象类，抽象类不能被实例化
class Animal(metaclass = abc.ABCMeta):

    all_type = 'animal'

    @abc.abstractmethod
    def run(self):
        pass

    @abc.abstractmethod
    def eat(self):
        pass

    @abc.abstractmethod
    def sleep(self):
        pass


class People(Animal):                # 定义类的抽象父类中有的相似属性，在子类中都必须定义，否则会报错

    def run(self):                   # 功能属性的命名必须与抽象类中对应功能属性名称相同
        print('peopel is running')

    def eat(self):
        print('people is eating')

    def sleep(self):
        print('people is sleeping ')

class Pig(Animal):

    def run(self):
        print('pig is running')

    def eat(self):
        print('pig is eating')

    def sleep(self):
        print('pig is sleeping')


people = People()
pig = Pig()

people.run()
people.eat()
people.sleep()

pig.run()
pig.eat()
pig.sleep()

二、多态

# 多态：同一种事物的多种心态，即父类下面的子类：子类中与父类中相似功能，在子类中表现的不同形态
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

# 多态性：可在不考虑对象类型的情况下而直接使用对象

po1 = People()
dog1 = Dog()
pig1 = Pig()
# 静态多态性：如任何类型都可以用运算符+进行运算
# 动态多态性，如下为动态多态

po1.talk()
dog1.talk()
pig1.talk()

# 也可定义一个函数来使用

def func(animal):
    animal.talk()
func(po1)
func(dog1)
func(pig1)



# 鸭子类型

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用


class Disk:
    def read(self):
        print('disk read')
    def write(self):
        print('disk  write')

class Text:
    def read(self):
        print('text  read')

    def write(self):
        print('text  write')

disk = Disk()
text = Text()

disk.read()
disk.write()

text.read()
text.write()

print(id(disk.read))
print(id(text.read))

多态的好处：
1.增加了程序的灵活性，以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
2.增加了程序额可扩展性，　通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用