Python面向对象编程原则：封装、继承和多态的应用示例

原创心已赠人 2024-12-22 16:42 1阅读 0赞

面向对象编程（Object-Oriented Programming, OOP）是现代编程的重要范式。在OOP中，有三个核心原则：封装、继承和多态。

1. 封装（Encapsulation）：
   封装是指将数据和与之相关的操作打包在一起，形成一个单独的实体。例如：

```python
class BankAccount:
    def __init__(self, account_number, balance=0):
        self.account_number = account_number
        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!")

# 创建一个银行账户实例
account = BankAccount("1234567890", 1000)

# 封装的存取款操作
account.deposit(500)
account.withdraw(200)  # 输出：Insufficient balance!
```

2. 继承（Inheritance）：
   继承是指子类（Subclass）继承父类（Superclass）的部分或全部属性和方法。例如：

```python
# 父类
class Animal:
    def __init__(self, name):
        self.name = name

# 定义一个通用的方法
    def make_sound(self):
        return "Animal sound..."

# 子类（继承父类的实例）
class Dog(Animal):
    def __init__(self, name, breed="Dog"):
        super().__init__(name)
        self.breed = breed

# 定义子类特有的方法
    def wag_tail(self):
        return "Wagging tail..."

# 创建和打印对象实例
my_dog = Dog("Rex", breed="Golden Retriever")
print(my_dog.name)  # 输出：Rex
print(my_dog.breed)   # 输出：Golden Retriever
print(my_dog.make_sound())  # 输出：Animal sound...
print(my_dog.wag_tail())  # 输出：Wagging tail...
```

3. 多态（Polymorphism）：
   多态是指同一个接口可以有多种不同的实现方式。在Python中，多态主要通过方法重写（Overriding Methods）来实现。

```python
# 定义一个抽象基类（Abstract Base Class）
class Shape:
    def draw(self):
        pass  # 这里只是一个空的返回语句

# 实现抽象基类的不同子类
class Circle(Shape):
    def draw(self):
        return "Drawing a circle..."

class Rectangle(Shape):
    def draw(self):
        return "Drawing a rectangle..."

# 创建并打印不同形状的对象实例
shapes = [Circle("C1"), 5), Rectangle("R1", 10, 8)]

for shape in shapes:
    print(shape.draw())  # 输出不同形状的画法
```

以上示例展示了面向对象编程的基本原则：封装、继承和多态。