python基础语法9-类的高级特性-优快云博客

本文链接：https://blog.youkuaiyun.com/wujianyouhun/article/details/146051151

Python 类的高级特性

在 Python 中，面向对象编程（OOP）通过继承、多态、方法重写、类方法、静态方法以及私有属性与封装等特性，提升了程序的灵活性、复用性与可维护性。本文将深入解析这些类的高级特性。

1. 继承与多态

1.1 继承

继承是 OOP 的基本特性之一。它允许一个类继承另一个类的属性和方法，从而实现代码的复用。子类不仅能够访问父类的方法和属性，还能扩展和修改它们。

class Animal:
    def speak(self):
        print("Animal speaks")

# 子类 Dog 继承自 Animal
class Dog(Animal):
    def speak(self):
        print("Woof!")

# 子类 Cat 继承自 Animal
class Cat(Animal):
    def speak(self):
        print("Meow!")

# 创建对象并调用 speak 方法
dog = Dog()
dog.speak()  # 输出: Woof!

cat = Cat()
cat.speak()  # 输出: Meow!

在上面的代码中，Dog 和 Cat 类继承了 Animal 类，并且重写了 speak 方法。这样，我们可以根据不同的对象类型调用各自实现的方法。

1.2 多态

多态是指同一操作作用于不同类型的对象时，能够表现出不同的行为。多态的实现依赖于方法的重写（override）。在 Python 中，多态可以通过子类重写父类的方法来实现。

def animal_sound(animal):
    animal.speak()

# 多态应用
dog = Dog()
cat = Cat()

animal_sound(dog)  # 输出: Woof!
animal_sound(cat)  # 输出: Meow!

animal_sound 函数接受任何继承自 Animal 类的对象，调用其 speak 方法。不同的对象（Dog 和 Cat）会展示不同的行为。

2. 方法重写 (`override`)

方法重写是指子类重写父类的方法，以改变或扩展其行为。Python 允许我们在子类中重新定义父类的方法。

2.1 基本方法重写示例

class Vehicle:
    def start(self):
        print("Vehicle is starting")

class Car(Vehicle):
    def start(self):
        print("Car is starting")

class Bike(Vehicle):
    def start(self):
        print("Bike is starting")

# 创建对象并调用重写后的方法
car = Car()
car.start()  # 输出: Car is starting

bike = Bike()
bike.start()  # 输出: Bike is starting

在这个例子中，Car 和 Bike 类重写了 Vehicle 类的 start 方法，从而提供了不同的实现。

2.2 使用 `super()` 调用父类方法

子类可以通过 super() 调用父类的方法，尤其是在子类中需要执行父类功能时。例如，在重写方法时，仍然希望保留父类方法的一部分行为。

class Dog:
    def speak(self):
        print("Woof!")

class LoudDog(Dog):
    def speak(self):
        super().speak()  # 调用父类的 speak 方法
        print("BARK BARK!")

dog = LoudDog()
dog.speak()
# 输出:
# Woof!
# BARK BARK!

3. 类方法 (`@classmethod`) 与静态方法 (`@staticmethod`)

3.1 类方法 (`@classmethod`)

类方法是与类绑定的方法，第一个参数是类本身，通常命名为 cls。类方法通常用于修改类的状态，或者作为工厂方法来创建对象实例。

class Person:
    population = 0

    def __init__(self, name):
        self.name = name
        Person.population += 1

    @classmethod
    def get_population(cls):
        return cls.population

# 调用类方法
print(Person.get_population())  # 输出: 0

# 创建实例
person1 = Person("Alice")
person2 = Person("Bob")

print(Person.get_population())  # 输出: 2

在这个例子中，get_population 是一个类方法，它通过 cls 来访问和修改类的属性 population。

3.2 静态方法 (`@staticmethod`)

静态方法不依赖于类的实例，也不访问类的状态。它通常用于实现与类相关的功能，但不需要访问类或实例的属性和方法。静态方法是独立的，它通常用来处理与类的其他部分无关的任务。

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

    @staticmethod
    def subtract(a, b):
        return a - b

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

静态方法通常用于不依赖于类的状态的计算功能。

4. 私有属性与封装 (`__`)

4.1 私有属性

在 Python 中，可以通过双下划线（__）前缀来定义私有属性。私有属性只能在类的内部访问，不能通过类外部直接访问。这种方式可以实现封装，从而保护类的内部状态不被外部直接修改。

class Person:
    def __init__(self, name, age):
        self.__name = name  # 私有属性
        self.__age = age    # 私有属性

    def introduce(self):
        print(f"Hi, I'm {self.__name} and I'm {self.__age} years old.")

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

# 直接访问私有属性会报错
# print(person.__name)  # AttributeError: 'Person' object has no attribute '__name'

4.2 封装与访问控制

虽然 Python 的私有属性可以避免直接访问，但它并没有严格的访问控制机制。如果需要访问私有属性，可以使用名称重整（name mangling）。

# 通过名称重整访问私有属性
print(person._Person__name)  # 输出: Alice

4.3 使用 `@property` 和 `@setter` 实现属性的访问控制

通过 @property 和 @<property_name>.setter 装饰器，Python 允许我们定义属性的访问器（getter）和修改器（setter），从而控制属性的访问和修改行为。

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

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, value):
        if value < 0:
            print("Age cannot be negative!")
        else:
            self.__age = value

# 创建对象
person = Person("Alice", 30)
print(person.age)  # 输出: 30

person.age = -5  # 输出: Age cannot be negative!
person.age = 35  # 正常设置
print(person.age)  # 输出: 35