创建类和对象

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

# 创建类的实例（对象）
buddy = Dog("Buddy", 4)
print(buddy.description())  # Buddy is 4 years old
print(buddy.speak("Woof!")) # Buddy says Woof!

继承与多态示例

# 继承示例
class Bulldog(Dog):  # 继承Dog类
    def run(self, speed):
        return f"{self.name} runs at {speed} mph"
    
    # 方法重写 (多态)
    def speak(self, sound="Grrr"):
        return super().speak(sound)

class Dachshund(Dog):
    # 方法重写 (多态)
    def speak(self, sound="Yap"):
        return f"{self.name} barks: {sound}!"

# 多态演示
def animal_sound(animal):
    print(animal.speak())

buddy = Bulldog("Buddy", 5)
jack = Dachshund("Jack", 3)

animal_sound(buddy)  # Buddy says Grrr
animal_sound(jack)   # Jack barks: Yap!

封装与属性控制

# 封装示例
class BankAccount:
    def __init__(self, owner, balance=0):
        # 私有属性 (命名约定，实际仍可访问)
        self._owner = owner
        self.__balance = balance  # 名称修饰，实际为_BankAccount__balance
    
    # 公开方法访问私有属性
    def get_balance(self):
        return self.__balance
    
    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 amount
        return 0

# 使用属性装饰器更Pythonic的方式
class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius
    
    @property
    def celsius(self):
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Temperature below absolute zero")
        self._celsius = value
    
    @property
    def fahrenheit(self):
        return (self._celsius * 9/5) + 32

temp = Temperature(25)
print(temp.fahrenheit)  # 77.0
temp.celsius = 30
print(temp.fahrenheit)  # 86.0

特殊方法（魔术方法）

# 特殊方法示例
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 __len__(self):
        return 2  # 二维向量
    
    # 调用实例本身
    def __call__(self, scale):
        return Vector(self.x * scale, self.y * scale)

v1 = Vector(2, 4)
v2 = Vector(1, 3)
print(v1 + v2)     # Vector(3, 7)
print(len(v1))     # 2
v3 = v1(0.5)       # 调用实例
print(v3)          # Vector(1.0, 2.0)

1 SOLID原则

• SRP 单一职责原则：一个类只负责一项功能
• OCP 开闭原则：对扩展开放，对修改关闭
• LSP 里氏替换原则：子类应能替换父类而不破坏程序
• ISP 接口隔离原则：客户端不应依赖不需要的接口
• DIP 依赖倒置原则：依赖抽象而非具体实现

2 组合优于继承

当需要复用代码时，优先考虑组合(composition)而不是继承(inheritance)，增加灵活性。

# 组合示例
class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self):
        self.engine = Engine()  # 组合
    
    def start(self):
        self.engine.start()
        print("Car started")

my_car = Car()
my_car.start()