一、OOP理论基础

1. 面向对象编程概述

面向对象编程(Object-Oriented Programming, OOP)是一种编程范式，它使用"对象"来设计应用程序和软件。OOP的核心概念包括：

• 类(Class)：对象的蓝图或模板
• 对象(Object)：类的实例
• 属性(Attribute)：对象的数据/特征
• 方法(Method)：对象的行为/功能

2. OOP四大基本原则

1. 封装(Encapsulation)
2. 将数据和行为包装在一个单元(类)中
3. 隐藏内部实现细节，只暴露必要接口
4. 继承(Inheritance)
5. 子类继承父类的属性和方法
6. 实现代码复用和层次化设计
7. 多态(Polymorphism)
8. 同一操作作用于不同对象可以有不同的解释
9. 主要通过方法重写和方法重载实现
10. 抽象(Abstraction)
11. 简化复杂现实，只关注相关特征
12. 通过抽象类和接口实现

二、Python OOP实践

1. 类与对象的基本使用

# 定义一个简单的类
class Dog:
    # 类属性（所有实例共享）
    species = "Canis familiaris"
    
    # 初始化方法（构造函数）
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age
    
    # 实例方法
    def bark(self):
        return f"{self.name} says woof!"
    
    def describe(self):
        return f"{self.name} is {self.age} years old"

# 创建对象（实例化）
dog1 = Dog("Buddy", 4)
dog2 = Dog("Milo", 2)

# 访问属性和方法
print(dog1.name)  # 输出: Buddy
print(dog2.bark())  # 输出: Milo says woof!
print(dog1.describe())  # 输出: Buddy is 4 years old
print(Dog.species)  # 输出: Canis familiaris

2. 封装与访问控制

Python中没有严格的私有属性，但可以通过命名约定实现封装：

class BankAccount:
    def __init__(self, account_holder, initial_balance):
        self.account_holder = account_holder  # 公开属性
        self._balance = initial_balance  # 保护属性（约定）
        self.__secret_code = 1234  # 私有属性（名称修饰）
    
    def deposit(self, amount):
        if amount > 0:
            self._balance += amount
            return True
        return False
    
    def withdraw(self, amount):
        if 0 < amount <= self._balance:
            self._balance -= amount
            return True
        return False
    
    def get_balance(self):
        return self._balance

# 使用示例
account = BankAccount("Alice", 1000)
account.deposit(500)
account.withdraw(200)
print(account.get_balance())  # 1300
print(account._balance)  # 可以访问但不推荐
# print(account.__secret_code)  # 会报错
print(account._BankAccount__secret_code)  # 可以访问但不应该这样做

3. 继承与多态

# 父类
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        raise NotImplementedError("子类必须实现此方法")

# 子类
class Dog(Animal):
    def speak(self):
        return f"{self.name} says woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says meow!"

# 多态示例
def animal_speak(animal):
    print(animal.speak())

# 使用
dog = Dog("Buddy")
cat = Cat("Whiskers")

animal_speak(dog)  # Buddy says woof!
animal_speak(cat)  # Whiskers says meow!

4. 类方法与静态方法

class Pizza:
    def __init__(self, ingredients):
        self.ingredients = ingredients
    
    # 实例方法
    def describe(self):
        return f"Pizza with {', '.join(self.ingredients)}"
    
    # 类方法 - 作为替代构造函数
    @classmethod
    def margherita(cls):
        return cls(["tomato sauce", "mozzarella"])
    
    @classmethod
    def prosciutto(cls):
        return cls(["tomato sauce", "mozzarella", "ham"])
    
    # 静态方法 - 与类相关但不访问实例或类
    @staticmethod
    def calculate_area(radius):
        return 3.14 * radius ** 2

# 使用
p1 = Pizza.margherita()
p2 = Pizza.prosciutto()
print(p1.describe())  # Pizza with tomato sauce, mozzarella
print(p2.describe())  # Pizza with tomato sauce, mozzarella, ham
print(Pizza.calculate_area(12))  # 452.16

5. 属性装饰器与属性控制

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
    
    @property
    def celsius(self):
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("温度不能低于绝对零度")
        self._celsius = value
    
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32
    
    @fahrenheit.setter
    def fahrenheit(self, value):
        self.celsius = (value - 32) * 5/9

# 使用
temp = Temperature(25)
print(temp.celsius)  # 25
print(temp.fahrenheit)  # 77.0

temp.fahrenheit = 100
print(temp.celsius)  # 37.777...

三、高级OOP概念

1. 魔术方法

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    # 字符串表示
    def __str__(self):
        return f"Vector({self.x}, {self.y})"
    
    # 加法运算符重载
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    # 乘法运算符重载
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)
    
    # 长度计算
    def __len__(self):
        return 2
    
    # 绝对值
    def __abs__(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5

# 使用
v1 = Vector(2, 4)
v2 = Vector(3, 1)
print(v1 + v2)  # Vector(5, 5)
print(v1 * 3)  # Vector(6, 12)
print(abs(v1))  # 4.472...

2. 抽象基类

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    
    @abstractmethod
    def perimeter(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2
    
    def perimeter(self):
        return 2 * 3.14 * self.radius

# 使用
rect = Rectangle(4, 5)
circle = Circle(3)

print(rect.area())  # 20
print(circle.perimeter())  # 18.84

3. 多重继承与MRO

class A:
    def method(self):
        print("A method")

class B(A):
    def method(self):
        print("B method")
        super().method()

class C(A):
    def method(self):
        print("C method")
        super().method()

class D(B, C):
    def method(self):
        print("D method")
        super().method()

# 使用方法解析顺序(MRO)
print(D.mro())  # [D, B, C, A, object]

d = D()
d.method()
# 输出:
# D method
# B method
# C method
# A method

四、实践案例 - 银行系统模拟

class Account:
    def __init__(self, account_number, account_holder, balance=0):
        self.account_number = account_number
        self.account_holder = account_holder
        self.balance = balance
        self.transactions = []
    
    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            self.transactions.append(("deposit", amount))
            return True
        return False
    
    def withdraw(self, amount):
        if 0 < amount <= self.balance:
            self.balance -= amount
            self.transactions.append(("withdraw", amount))
            return True
        return False
    
    def transfer(self, amount, target_account):
        if self.withdraw(amount):
            target_account.deposit(amount)
            self.transactions.append(("transfer", amount, target_account.account_number))
            return True
        return False
    
    def get_transactions(self):
        return self.transactions
    
    def __str__(self):
        return f"Account {self.account_number} - Balance: {self.balance}"

class SavingsAccount(Account):
    def __init__(self, account_number, account_holder, balance=0, interest_rate=0.01):
        super().__init__(account_number, account_holder, balance)
        self.interest_rate = interest_rate
    
    def add_interest(self):
        interest = self.balance * self.interest_rate
        self.deposit(interest)
        return interest
    
    def __str__(self):
        return f"Savings Account {self.account_number} - Balance: {self.balance}, Interest Rate: {self.interest_rate}"

class Bank:
    def __init__(self):
        self.accounts = {}
    
    def create_account(self, account_type, account_number, account_holder, **kwargs):
        if account_number in self.accounts:
            print("账号已存在")
            return None
        
        if account_type == "savings":
            account = SavingsAccount(account_number, account_holder, **kwargs)
        else:
            account = Account(account_number, account_holder, **kwargs)
        
        self.accounts[account_number] = account
        return account
    
    def get_account(self, account_number):
        return self.accounts.get(account_number)
    
    def transfer(self, from_account_num, to_account_num, amount):
        from_account = self.get_account(from_account_num)
        to_account = self.get_account(to_account_num)
        
        if from_account and to_account:
            return from_account.transfer(amount, to_account)
        return False
    
    def __str__(self):
        return f"Bank with {len(self.accounts)} accounts"

# 使用示例
bank = Bank()

# 创建账户
acc1 = bank.create_account("normal", "001", "Alice", balance=1000)
acc2 = bank.create_account("savings", "002", "Bob", balance=500, interest_rate=0.02)

print(acc1)
print(acc2)

# 存款和取款
acc1.deposit(500)
acc1.withdraw(200)

# 转账
bank.transfer("001", "002", 300)

# 添加利息
acc2.add_interest()

# 查看交易记录
print("\nAlice的交易记录:")
for t in acc1.get_transactions():
    print(t)

print("\nBob的交易记录:")
for t in acc2.get_transactions():
    print(t)

# 查看余额
print(f"\nAlice的余额: {acc1.balance}")
print(f"Bob的余额: {acc2.balance}")

学习建议

1. 循序渐进：从简单类开始，逐步引入更复杂的概念
2. 实际案例：使用学生熟悉的例子（如车辆、动物、银行账户等）
3. 交互式练习：让学生修改现有代码并观察结果
4. 调试实践：故意引入错误让学生修复
5. 项目驱动：通过小型项目（如学生管理系统）巩固概念

通过学习这个教程我们可以掌握Python面向对象编程的核心概念和实践技能！

持续更新Python编程学习日志与技巧，敬请关注！