【Python】Python面向对象编程进阶：继承、多态与封装

Python面向对象编程进阶：继承、多态与封装

Python 是一种支持面向对象编程（OOP）的语言。OOP 通过封装、继承和多态等特性，使得代码结构更清晰、可重用性更高。本文将深入讲解 Python 的面向对象编程进阶，包括类的继承、多态和封装，以帮助理解如何通过 OOP 提高代码效率与可维护性。

目录

1. 面向对象编程简介
2. 类和对象的基本概念回顾
3. Python 的类继承概述
4. 单继承与多继承
5. 父类方法的重写（Override）
6. super() 函数的应用
7. 多态的基本概念与实现
8. 鸭子类型（Duck Typing）与动态多态性
9. 封装的意义与应用
10. 公有属性与私有属性
11. getter 和 setter 方法
12. 面向对象编程进阶实战案例

1. 面向对象编程简介

面向对象编程（OOP）是一种程序设计范式，将现实世界中的事物抽象为对象，以更清晰的方式表示程序的结构。OOP 的核心概念包括类、对象、封装、继承和多态。OOP 通过类和对象的设计来模拟真实世界的事物，帮助我们更好地组织代码。

2. 类和对象的基本概念回顾

在 Python 中，类是对象的蓝图，定义了对象的属性和行为，而对象则是类的实例。类通过 class 关键字定义。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"Hello, my name is {self.name} and I'm {self.age} years old.")

# 创建对象
person1 = Person("Alice", 25)
person1.introduce()

3. Python 的类继承概述

继承是 OOP 中的重要特性，使得一个类可以继承另一个类的属性和方法。继承有助于代码复用，并可以通过拓展已有类来创建新类。

# 基类
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

# 派生类
class Dog(Animal):
    def speak(self):
        print(f"{self.name} barks.")

dog = Dog("Buddy")
dog.speak()

4. 单继承与多继承

Python 支持单继承和多继承。单继承指一个类只能有一个直接父类，而多继承指一个类可以继承多个父类。多继承可能带来更强大的功能，但也带来了复杂性。

# 多继承示例
class Flyer:
    def fly(self):
        print("This animal can fly.")

class Swimmer:
    def swim(self):
        print("This animal can swim.")

class Duck(Flyer, Swimmer):
    pass

duck = Duck()
duck.fly()
duck.swim()

5. 父类方法的重写（Override）

重写是指在派生类中重新定义父类的方法。通过重写，派生类可以拥有不同的行为，而不必修改父类的代码。

class Animal:
    def speak(self):
        print("Animal makes a sound.")

class Cat(Animal):
    def speak(self):
        print("Meow")

cat = Cat()
cat.speak()

6. super() 函数的应用

super() 函数用于调用父类的方法。它在继承关系复杂时特别有用，确保父类的方法在子类中得以调用。

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

    def speak(self):
        print(f"{self.name} makes a sound.")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

    def speak(self):
        super().speak()
        print(f"{self.name} barks.")

dog = Dog("Buddy", "Labrador")
dog.speak()

7. 多态的基本概念与实现

多态指同一方法在不同对象中表现出不同的行为。多态性通常通过继承和方法重写来实现。

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Bark")

class Cat(Animal):
    def speak(self):
        print("Meow")

def animal_sound(animal):
    animal.speak()

dog = Dog()
cat = Cat()
animal_sound(dog)
animal_sound(cat)

8. 鸭子类型（Duck Typing）与动态多态性

Python 中的多态性不依赖于类继承，而是基于“鸭子类型”：只要对象表现出某种行为，就可以使用它，即“看起来像鸭子，走起来像鸭子，就是鸭子”。

class Bird:
    def fly(self):
        print("Bird flies")

class Airplane:
    def fly(self):
        print("Airplane flies")

def lift_off(entity):
    entity.fly()

bird = Bird()
airplane = Airplane()
lift_off(bird)
lift_off(airplane)

9. 封装的意义与应用

封装是 OOP 的另一核心特性，通过限制直接访问对象的属性和方法来实现，确保数据安全。在 Python 中，通过将属性命名为“_”或“__”开头的方式进行封装。

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())  # 输出: 1500

10. 公有属性与私有属性

公有属性可以被外部访问，而私有属性（双下划线开头）在类外部无法直接访问。私有属性的封装防止了数据被意外修改。

class Employee:
    def __init__(self, name, salary):
        self.name = name  # 公有属性
        self.__salary = salary  # 私有属性

    def display_info(self):
        print(f"Name: {self.name}, Salary: {self.__salary}")

emp = Employee("John", 5000)
print(emp.name)   # 可以访问
# print(emp.__salary)  # 无法访问

11. getter 和 setter 方法

getter 和 setter 是访问和修改私有属性的特殊方法。通过这些方法可以控制属性的访问权限并进行数据校验。

class Student:
    def __init__(self, name, grade):
        self.__name = name
        self.__grade = grade

    def get_grade(self):
        return self.__grade

    def set_grade(self, grade):
        if 0 <= grade <= 100:
            self.__grade = grade
        else:
            print("Invalid grade")

student = Student("Alice", 90)
print(student.get_grade())
student.set_grade(85)
print(student.get_grade())

12. 面向对象编程进阶实战案例

以下是一个简单的银行系统案例，展示了如何使用继承、封装和多态性。

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient balance")

    def get_balance(self):
        return self.__balance

class SavingsAccount(Account):
    def __init__(self, owner, balance=0, interest_rate=0.01):
        super().__init__(owner, balance)
        self.interest_rate = interest_rate

    def add_interest(self):
        interest = self.get_balance() * self.interest_rate
        self.deposit(interest)

# 创建储蓄账户对象
savings = SavingsAccount("Alice", 1000)
savings.add_interest()
print(savings.get_balance())  # 输出: 带利息的余额

总结

Python 面向对象编程的三个核心特性——继承、封装和多态性——为编写高效、结构良好的代码提供了强大的工具。继承提高了代码的复用性，封装保证了数据安全，多态性则提升了代码的灵活性。掌握这些特性，能够在大型项目中编写出更具扩展性和可维护性的代码。