封装、继承和多态是面向对象的三大特点；直接看Python中是怎么实现的

封装 继承 多态

封装<a id=01></a>

首先定义一个 Human 类，初始化类的属性和方法：

1class Human:
2    def __init__(self):
3        # 这是可以公共知道的属性
4        self.age = None  # 年龄
5        self.height = None  # 身高
6
7        # 这是私有属性，如持有多少钱
8        self.__money = None
9
10    # 为了让自己使用自己的钱，要设置方法来获取
11    def getMoney(self):
12        return self.__money
13    # 设置money值
14    def setMoney(self, money):
15        if money > 0:
16            self.__money = money
17    def speak(self):
18        pass

这样我们就可以说这个类完成了封装。可以看出封装就是把众多属性和方法合在一起，形成一个功能。这是一种编程思想。

继承<a id=02></a>

前面我们定义了 Human 类，现在我们还想定义一个类，它可以使用 Human 类的功能，同时也有自己的功能，可以使用继承：

1class LocalHuman(Human):
2    
3    # 这是这个类独有的功能
4    def speak(self):
5        print('我会说本地话。')

运行测试代码：

1if __name__ == '__main__':
2    # 创建LocalHuman实例
3    local_human = LocalHuman()
4    # 测试
5    # 这是继承自Human类的
6    print(local_human.height)
7    print(local_human.age)
8    print(local_human.getMoney())
9    # 这是自己的
10    local_human.speak()

结果如下： 这样的过程就是继承，当需要使用的功能有部分重复时，我们优先使用继承的方法，避免再一次造出重复的功能。

多态<a id=03></a>

定义一个 Rich 类，它继承 Human 类：

1class Rich(Human):
2    def __init__(self):
3        self.age = 1
4        self.height = 10
5        # 部分属性和父类不同
6        self.setMoney(100000000)
7
8    def speak(self):
9        print('我喜欢极限运动！')

定义一个函数接收 Human 对象，来展示 Human 对象的不同形态：

1def show(h: Human):
2    print(h.getMoney())
3    h.speak()

测试代码：

1if __name__ == '__main__':
2    # 创建LocalHuman实例
3    local_human = LocalHuman()
4    # 创建Rich实例
5    rich = Rich()
6    # 测试
7    # 调用show 函数，显示他们的不同
8    show(local_human)
9    print('-' * 31)  # 分隔符
10    show(rich)

运行结果：

可以看出，同一个函数传入父类是Human类，可以表示出多种形态，这就是Human类的多态。