一、面向对象基础概念

1. 什么是面向对象编程（OOP）？

OOP是一种以对象为中心的编程范式，通过将数据（属性）和操作数据的方法（行为）封装在一起，模拟现实世界的实体和交互。
核心思想：万物皆对象（Everything is an Object）。

2. 类（Class） vs 对象（Object）

• 类：对象的模板或蓝图，定义了对象的属性和方法。

class Dog:
    def __init__(self, name, age):
        self.name = name  # 属性
        self.age = age
    def bark(self):     # 方法
        print(f"{self.name} says: 汪汪！")

• 对象：类的实例，通过类创建的具体实体。

my_dog = Dog("旺财", 3)  # 创建对象
my_dog.bark()            # 调用对象方法

二、类的定义与对象创建

1. 定义类

• 使用class关键字定义类，类名通常首字母大写。

class NetworkDevice:
    def __init__(self, ip, model):
        self.ip = ip        # 属性：IP地址
        self.model = model  # 属性：型号
        self.status = "offline"  # 属性：状态

    def connect(self):
        self.status = "online"
        print(f"设备 {self.ip} 已连接")

    def disconnect(self):
        self.status = "offline"
        print(f"设备 {self.ip} 已断开")

2. 创建对象（实例化）

• 通过类名调用，传递参数给__init__方法（构造函数）。

router = NetworkDevice("192.168.1.1", "Cisco ISR 4000")
switch = NetworkDevice("10.0.0.1", "Huawei S5700")

三、类的属性与方法

1. 属性

• 实例属性：属于对象的属性，通过self访问。

print(router.ip)  # 输出：192.168.1.1

• 类属性：属于类的属性，所有实例共享。

class Computer:
    brand = "Lenovo"  # 类属性
    def __init__(self, model):
        self.model = model  # 实例属性

comp1 = Computer("ThinkPad")
comp2 = Computer("Legion")
print(comp1.brand)  # 输出：Lenovo（共享）

2. 方法

• 实例方法：操作实例属性，第一个参数必须是self。

def upgrade_firmware(self):
    print(f"正在升级 {self.model} 的固件...")

• 类方法：操作类属性，使用@classmethod装饰器。

@classmethod
def set_brand(cls, new_brand):
    cls.brand = new_brand

• 静态方法：与类无关，仅作为工具函数，使用@staticmethod装饰器。

@staticmethod
def check_connection(ip):
    print(f"检查 {ip} 的连通性...")

四、封装：隐藏内部细节

封装通过访问控制保护数据，防止外部直接修改对象属性。

1. 私有属性与方法

• 前缀__表示私有（实际是名称修饰，非严格私有）。

class Router:
    def __init__(self):
        self.__secret_key = "12345"  # 私有属性

    def __encrypt(self):  # 私有方法
        print("加密数据...")

    def public_method(self):
        self.__encrypt()  # 内部可访问

2. 通过getter/setter访问私有属性

class User:
    def __init__(self, password):
        self.__password = password  # 私有属性

    def get_password(self):
        return self.__password

    def set_password(self, new_password):
        if len(new_password) >= 8:
            self.__password = new_password
        else:
            print("密码长度不足！")

user = User("123456")
print(user.get_password())  # 输出：123456
user.set_password("abc")    # 输出：密码长度不足！

五、继承：复用代码与扩展功能

继承允许子类继承父类的属性和方法，实现代码复用。

1. 单继承

class Animal:
    def speak(self):
        print("动物发出声音")

class Dog(Animal):
    def speak(self):
        print("汪汪！")

dog = Dog()
dog.speak()  # 输出：汪汪！（子类覆盖父类方法）

2. 多继承

class FlyingAnimal:
    def fly(self):
        print("正在飞行")

class Eagle(Animal, FlyingAnimal):
    pass

eagle = Eagle()
eagle.speak()  # 输出：汪汪！（继承自Animal）
eagle.fly()    # 输出：正在飞行（继承自FlyingAnimal）

六、多态：同一接口不同实现

多态允许不同类的对象使用相同的接口，提高代码灵活性。

1. 方法重写

class Shape:
    def area(self):
        pass

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

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

shapes = [Circle(2), Rectangle(3, 4)]
for shape in shapes:
    print(shape.area())  # 输出：12.56（圆）和12（矩形）

2. 鸭子类型（动态类型语言特性）

Python不强制类型检查，只要对象有对应方法即可。

def make_sound(animal):
    animal.speak()

make_sound(Dog())   # 输出：汪汪！
make_sound(Cat())   # 输出：喵喵！（假设Cat类有speak方法）

七、实战案例：网络设备管理系统

需求：管理网络设备（路由器、交换机），支持添加设备、连接设备、统计在线设备数量。

class NetworkDevice:
    online_devices = 0  # 类属性：统计在线设备数

    def __init__(self, ip, model):
        self.ip = ip
        self.model = model
        self.status = "offline"

    def connect(self):
        self.status = "online"
        NetworkDevice.online_devices += 1
        print(f"设备 {self.ip} ({self.model}) 已连接")

    def disconnect(self):
        self.status = "offline"
        NetworkDevice.online_devices -= 1
        print(f"设备 {self.ip} ({self.model}) 已断开")

    @classmethod
    def get_online_count(cls):
        return cls.online_devices

# 创建设备实例
router = NetworkDevice("192.168.1.1", "Cisco ISR 4000")
switch = NetworkDevice("10.0.0.1", "Huawei S5700")

# 操作设备
router.connect()
switch.connect()

# 统计在线设备
print(f"当前在线设备数：{NetworkDevice.get_online_count()}")  # 输出：2

# 断开设备
router.disconnect()
print(f"当前在线设备数：{NetworkDevice.get_online_count()}")  # 输出：1

八、常见问题与解决方案

1. 类属性与实例属性冲突

class MyClass:
    count = 0  # 类属性

    def __init__(self):
        self.count = 1  # 实例属性覆盖类属性

obj = MyClass()
print(obj.count)    # 输出：1（实例属性）
print(MyClass.count)  # 输出：0（类属性仍存在）

2. 私有属性无法直接访问

class MyClass:
    def __init__(self):
        self.__secret = 42

obj = MyClass()
# print(obj.__secret)  # 报错：AttributeError
print(obj._MyClass__secret)  # 通过名称修饰访问（不推荐）

3. 多继承的菱形问题（方法解析顺序）

Python使用C3线性化算法确定方法调用顺序，可通过mro()查看。

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

class B(A):
    def test(self):
        print("B")

class C(A):
    def test(self):
        print("C")

class D(B, C):
    pass

d = D()
d.test()  # 输出：B（MRO顺序：D → B → C → A）
print(D.mro())  # 输出：[D, B, C, A, object]

九、总结与下一步

• 核心收获：
• 类与对象：封装数据与行为。
• 继承：代码复用与扩展。
• 多态：同一接口不同实现。
• 封装：隐藏内部细节，保护数据安全。