Python基础：面向对象三大特征之一【多态】

（一）多态

多态：简单地说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法。

• 提高程序的可扩展性和可维护性

示例：

class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头...')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼...')
class Person(object):
    def eat(self):
        print('人吃五谷杂粮')

# 定义一个类
def fun(obj):
    obj.eat()

fun(Dog())
fun(Cat())
fun(Animal())
fun(Person())

运行结果：

 （二）静态语言和动态语言

静态语言和动态语言关于多态的区别：

（1）静态语言：在编译时确定所有变量的类型，变量的类型不能改变。在使用之前需要声明变量类型，严格区分不同类型的变量，如C++、Java等。

静态语言实现多态的三个必要条件：

1. 继承
2. 方法重写
3. 父类引用指向子类对象

（2）动态语言：在运行时确定变量类型，变量的类型可以改变。不需要显式地声明变量类型，变量类型可以根据赋值语句自动推导出来，如Python、Javascript等。

动态语言的多态崇尚“鸭子类型”当看到一只鸟走起来像鸭子、游泳起来像鸭子、走起来也像鸭子，那么这只鸟就可以被称之为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为。

（三）类的特殊属性和特殊方法

（1）特殊属性与特殊方法

	名称	描述
特殊 属性	__dict__	获得类对象或实例对象所绑定的所有属性和方法的字典
特殊 方法	__len__()	通过重写__len__()方法，让内置函数len()的参数可以是自己定义类型
	__add__()	通过重写__add__()方法，可以使用自定义对象具有“+”功能
	__new__()	用于创建对象
	__init__()	对创建对象进行初始化

示例1：

class A(object):
    pass
class B(object):
    pass
class C(A, B):
    def __init__(self, name, age):
        self.name = name
        self.age = age
class D(A):
    pass
# 创建C类的一个对象
x = C('杰克', 20)  # x是C类的一个实例对象
print(x.__init__)  # 创建实例对象的一个属性字典
print(C.__init__)
print(x.__class__)  # <class '__main__.C'>输出了对象所属的类
print(C.__bases__)  # C类的父类类型元素
print(C.__base__)  # 选择较近的父类类型元素，例如A
print(C.__mro__)  # 类的层次结构
print(A.__subclasses__())  # 表明A的子类是谁

运行结果：

 

示例2：

class Student(object):
    def __init__(self, name):
        self.name = name
    def __add__(self, other):
        return self.name+other.name
    def __len__(self):
        return len(self.name)

stu1 = Student('Marry')
stu2 = Student('李明')
s = stu1 + stu2  # 实现这一运行操作有两种方法，第一种，在原有类中定义__add__方法，第二种，直接进行__add__方法的编写
print(s)
print('-------------------------')
s = stu1.__add__(stu2)
print(s)
lst = [11, 12, 13, 14]
print(len(lst))  # len是内置函数len，（可以判断有几个元素）
print(len(stu1))

运行结果：

（2）new和init演示创建对象的过程

new和init演示创建对象的过程：

class Person(object):
    def __new__(cls, *args, **kwargs):
        print('__new__被调用执行了,cls的id值为：{0}'.format(id(cls)))
        obj = super().__new__(cls)
        print('创建的对象的id为：{0}'.format(id(obj)))
        return obj
    def __init__(self, name, age):  # 重新定义一个方法（构造一个方法）
        print('__init__被调用了，self的id值为：{0}'.format(id(self)))
        self.name = name
        self.age = age
print('object这个类对象的id为：{0}'.format(id(object)))
print('Person这个类对象的id为：{0}'.format(id(Person)))
# 创建Person的实例对象
p1 = Person('李明', 20)
print('p1这个Person这个类的实例对象的id为：{0}'.format(id(p1)))

运行结果：

new和init的作用：

new创建对象，而init在后是为这个对象的属性，实例属性进行赋值最后将创建的对象放到p1当中去进行存储。

（四）类的浅拷贝与深拷贝

变量的赋值操作：只是形成两个变量，实际上还是指向同一个对象。

浅拷贝：python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象。

• 通俗理解：浅拷贝就像是复制了一个指向原始数据的指针，两个指针指向同一个内存地址，修改其中一个数据，另一个数据也会受到影响。

深拷贝：使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不同。

• 通俗理解：深拷贝就像是完全复制了一个新的数据，两个数据在不同的内存地址，修改其中一个数据，另一个数据不会受到影响。

示例：

# 变量的赋值
class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self, cpu, disk):
        self.cpu = cpu
        self.disk = disk

# 变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1, id(cpu1))
print(cpu2, id(cpu2))

# 浅拷贝
print('-------------------------------------')
disk = Disk()  # 创建一个硬盘类的对象
computer = Computer(cpu1, disk)

# 进行浅拷贝
print('-----------------浅拷贝---------------')
import copy
print(disk)
computer2 = copy.copy(computer)
print(computer, computer.cpu, computer.disk)
print(computer2, computer2.cpu, computer2.disk)
# 进行深拷贝
print('----------------深拷贝-----------------')
computer3 = copy.deepcopy(computer)
print(computer, computer.cpu, computer.disk)
print(computer3, computer3.cpu, computer3.disk)

运行结果：