【Python高级】面向对象编程详解：继承、多态、封装

Python是一种面向对象的编程语言，面向对象编程是其核心之一。在Python中，类是一种定义了一组属性和方法的对象。它可以看作是一种模板或蓝图，通过它可以创建多个实例对象。本文将详细介绍面向对象编程中的三个重要概念：继承、多态和封装。

一、继承

继承是面向对象编程中的一种机制，它允许一个类从另一个类中继承属性和方法。在Python中，使用类名和圆括号表示继承关系。例如：

```
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "woof"

class Cat(Animal):
    def speak(self):
        return "meow"
```

在这个例子中，类`Dog`和`Cat`继承了类`Animal`的属性和方法。`Animal`是一个基类，也称为父类，`Dog`和`Cat`是派生类，也称为子类。`Dog`和`Cat`实现了父类`Animal`中定义的`speak()`方法，并且根据需要进行修改。

二、多态

多态是指同样的方法或操作在不同的对象上产生不同的行为或结果。在面向对象编程中，多态常常和继承相结合使用。在上述例子中，`Dog`和`Cat`的`speak()`方法就是多态的一个例子。使用多态可以提高代码的灵活性和可复用性。

在Python中，多态是默认的行为，因为它是一种动态类型语言，变量的类型在运行时才确定。例如：

```
def make_speak(animal):
    print(animal.speak())

dog = Dog("Fido")
cat = Cat("Whiskers")

make_speak(dog)
make_speak(cat)
```

在这个例子中，`make_speak()`函数接受一个参数`animal`，这个参数可以是任何实现`speak()`方法的对象。当传入一个`Dog`实例时，会调用`Dog`的`speak()`方法，当传入一个`Cat`实例时，会调用`Cat`的`speak()`方法。

三、封装

封装是面向对象编程中的一种机制，它将属性和方法包装在一个类中，限制了外部访问方式，并保护了对象的状态。在Python中，封装通过属性和方法的访问限制实现。

在Python中，属性和方法都有一定的访问限制。属性可以分为公有属性和私有属性，公有属性可以在类外部访问，私有属性只能在类内部访问。方法可以分为公有方法、私有方法和受保护方法，公有方法可以在类外部访问，私有方法和受保护方法只能在类内部访问。

例如：

```
class Person:
    def __init__(self, name):
        self.name = name
        self.__age = 18

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if age > 0 and age < 150:
            self.__age = age
        else:
            print("invalid age")

person = Person("Alice")
person.set_age(20)
print(person.get_age())

person.__age = -1
print(person.get_age()) # 输出20
```

在这个例子中，`Person`类有一个私有属性`__age`，它只能在类内部访问。`Person`类有两个公有方法`get_age()`和`set_age()`，它们可以在类外部访问。`set_age()`方法对输入的年龄进行判断，如果年龄不在有效范围内，则输出错误信息。`get_age()`方法用于获取私有属性`__age`的值。在类外部，如果直接修改`person.__age`的值，不会影响到实际的私有属性`__age`，因为Python会将`__age`转换成`_Person__age`，使其变成一个伪私有属性，只能在类内部访问。

总结

继承、多态和封装是面向对象编程中三个重要概念，它们可以让代码更加灵活和可复用。在Python中，使用类来实现面向对象编程，可以方便地使用继承、多态和封装。