当前位置：首页 > Python > 正文

Python面向对象编程(OOP)完全指南 | 类与对象详解

LouSengRui
Python
2025-08-08
523

Python面向对象编程(OOP)完全指南

什么是面向对象编程？

面向对象编程(Object-Oriented Programming, OOP)是一种编程范式，它将程序组织为对象的集合，这些对象包含数据和操作数据的方法。

Python从设计之初就是一门面向对象的语言，它提供了强大的OOP功能，包括：

类(Class) - 创建对象的蓝图
对象(Object) - 类的实例
继承(Inheritance) - 创建新类的方式
封装(Encapsulation) - 隐藏实现细节
多态(Polymorphism) - 使用统一接口操作不同对象

类与对象

类是创建对象的模板，它定义了对象将包含的数据(属性)和行为(方法)。

对象是类的实例，具有类定义的属性和方法。

创建类与对象示例

# 定义一个简单的类
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 description(self):
        return f"{self.name} is {self.age} years old"

# 创建类的实例 (对象)
my_dog = Dog("Buddy", 3)
your_dog = Dog("Lucy", 5)

# 访问属性和方法
print(my_dog.name)        # 输出: Buddy
print(your_dog.age)       # 输出: 5
print(my_dog.bark())      # 输出: Buddy says woof!
print(your_dog.description()) # 输出: Lucy is 5 years old
print(Dog.species)        # 输出: Canis familiaris

继承

继承允许我们定义一个类，它继承另一个类的属性和方法。

被继承的类称为父类或基类，新类称为子类或派生类。

继承示例

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

# 子类继承
class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

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

# 创建子类实例
my_cat = Cat("Whiskers")
my_duck = Duck("Donald")

print(my_cat.speak())  # 输出: Whiskers says Meow!
print(my_duck.speak()) # 输出: Donald says Quack!

封装

封装是指将数据(属性)和行为(方法)捆绑在一起，并对外部隐藏实现细节。

在Python中，我们使用命名约定来表示访问权限：

public - 默认，无前缀
_protected - 单下划线开头(约定为受保护)
__private - 双下划线开头(名称修饰)

封装示例

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance  # 私有属性
    
    # 公共方法访问私有属性
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return f"存款成功，余额: {self.__balance}"
        return "存款金额必须大于0"
    
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            return f"取款成功，余额: {self.__balance}"
        return "取款金额无效"
    
    def get_balance(self):
        return self.__balance

# 创建账户
account = BankAccount("Alice", 1000)

print(account.deposit(500))    # 存款成功，余额: 1500
print(account.withdraw(200))   # 取款成功，余额: 1300
print(account.get_balance())   # 1300

# 尝试直接访问私有属性（会失败）
# print(account.__balance)      # 引发AttributeError

多态

多态是指不同类的对象对同一消息(方法调用)做出不同响应的能力。

Python的多态是"鸭子类型"的体现——如果它像鸭子一样走路，像鸭子一样嘎嘎叫，那它就是鸭子。

多态示例

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

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

# 多态函数
def calculate_area(shape):
    return shape.area()

# 创建不同形状对象
rect = Rectangle(4, 5)
circle = Circle(3)

# 使用同一函数计算不同形状的面积
print(calculate_area(rect))    # 输出: 20
print(calculate_area(circle))  # 输出: 28.26

特殊方法

Python类可以定义特殊方法(双下划线方法)，用于实现操作符重载和内置函数支持。

特殊方法示例

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)

# 创建向量
v1 = Vector(2, 3)
v2 = Vector(4, 5)

# 使用特殊方法
print(v1)              # 输出: Vector(2, 3)
v3 = v1 + v2
print(v3)              # 输出: Vector(6, 8)
v4 = v1 * 3
print(v4)              # 输出: Vector(6, 9)