面向对象编程

类与对象

类的定义与实例化

• 类是对象的蓝图，定义了对象的属性和行为。
• 对象是类的实例，每个对象有独立的数据属性和方法。

# 定义一个类
class Person:
    # 类的构造方法，定义初始化属性
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 类的方法
    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

# 实例化对象
p1 = Person("Alice", 25)
p1.greet()  # 输出: Hello, my name is Alice and I am 25 years old.

类的属性与方法

• 属性: 类的变量，表示类的状态或数据。
• 方法: 类的函数，定义类的行为或操作。

class Dog:
    # 类属性，所有实例共享
    species = "Canis Familiaris"
    
    def __init__(self, name, breed):
        # 实例属性，每个对象独有
        self.name = name
        self.breed = breed

    # 实例方法
    def bark(self):
        print(f"{self.name} is barking!")

dog1 = Dog("Buddy", "Golden Retriever")
dog2 = Dog("Max", "Bulldog")

# 访问属性
print(dog1.name, dog1.breed)  # 输出: Buddy Golden Retriever
print(dog2.species)  # 输出: Canis Familiaris

# 调用方法
dog1.bark()  # 输出: Buddy is barking!

类的继承

继承允许一个类继承另一个类的属性和方法，减少代码冗余，增加代码重用性。

单继承

# 父类
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("Rex")
dog.speak()  # 输出: Rex barks.

多继承

Python 支持多继承，一个类可以继承多个父类。

class A:
    def method_a(self):
        print("Method from class A")

class B:
    def method_b(self):
        print("Method from class B")

# C类同时继承A和B类
class C(A, B):
    pass

c = C()
c.method_a()  # 输出: Method from class A
c.method_b()  # 输出: Method from class B

重写与多态

• 重写: 子类可以重写父类中的方法，以便在子类中提供不同的功能。
• 多态: 不同的类可以定义相同的方法名，而实际调用时会根据对象类型执行对应的方法。

class Bird:
    def speak(self):
        print("Chirp chirp")

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

class Cat(Animal):
    def speak(self):
        print(f"{self.name} meows.")

# 多态：不同对象调用相同的方法
animals = [Dog("Rex"), Cat("Whiskers"), Bird()]

for animal in animals:
    animal.speak()

# 输出: 
# Rex barks.
# Whiskers meows.
# Chirp chirp

封装与访问控制

封装是将数据隐藏在对象内部，只允许通过特定的方式访问和修改。Python 通过属性的命名方式实现封装和访问控制：

• 公有属性: 直接访问，不加下划线。
• 受保护属性: 以单下划线开头，仅限类内部和子类访问。
• 私有属性: 以双下划线开头，只能在类内部访问。

class Car:
    def __init__(self, brand, speed):
        self.brand = brand  # 公有属性
        self._speed = speed  # 受保护属性
        self.__fuel = 100  # 私有属性

    def show_fuel(self):
        return self.__fuel  # 内部可以访问私有属性

car = Car("Toyota", 120)

# 访问公有属性
print(car.brand)  # 输出: Toyota

# 访问受保护属性（不推荐）
print(car._speed)  # 输出: 120

# 无法直接访问私有属性
# print(car.__fuel)  # 会报错

# 通过方法访问私有属性
print(car.show_fuel())  # 输出: 100

类的高级特性

静态方法与类方法

• 静态方法: 不依赖于类或实例，可以通过类名直接调用。使用 @staticmethod 装饰器定义。
• 类方法: 只能访问类变量，而不能访问实例变量，使用 @classmethod 装饰器定义。

class Utility:
    @staticmethod
    def add(a, b):
        return a + b

    @classmethod
    def description(cls):
        return f"This is a utility class."

# 静态方法调用
print(Utility.add(5, 3))  # 输出: 8

# 类方法调用
print(Utility.description())  # 输出: This is a utility class.

魔术方法（Magic Methods）

魔术方法是以双下划线开头和结尾的特殊方法，它们定义了类的某些行为，例如对象的初始化、字符串表示等。

• __init__: 初始化对象时调用的构造方法。
• __del__: 对象被销毁时调用的析构方法。
• __str__: 定义对象的字符串表示，用于 print() 等输出。
• __repr__: 定义对象的官方字符串表示，用于调试。

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

    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"

    def __repr__(self):
        return f"Person('{self.name}', {self.age})"

# 创建对象
p = Person("Alice", 30)

# 调用__str__方法
print(p)  # 输出: Person(name=Alice, age=30)

# 调用__repr__方法
print(repr(p))  # 输出: Person('Alice', 30)

运算符重载

魔术方法还可以用来重载运算符，例如 +、- 等。

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 重载加法运算符
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2  # 使用__add__方法
print(v3)  # 输出: Vector(4, 6)