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

【30天玩转python】高级面向对象编程

article 2024/9/24 22:28:50

高级面向对象编程

面向对象编程（Object-Oriented Programming，简称 OOP）是 Python 的核心编程范式之一。Python 不仅支持基础的面向对象特性，如类和对象，还支持更高级的特性，如继承、多态、封装、抽象以及元类等。这些特性使得 Python 的面向对象编程更具灵活性和可扩展性。

1. 类的继承

继承是面向对象编程中一个核心概念，它允许一个类继承另一个类的属性和方法。通过继承，子类可以复用父类的代码，同时也可以添加新的功能，或重写父类的功能。

1.1 单继承

单继承是指一个类只继承一个父类。在 Python 中，使用 class SubClass(ParentClass) 来定义子类。

示例：单继承

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

1.2 多继承

Python 支持多继承，一个类可以同时继承多个父类。多继承虽然提供了灵活性，但也容易引发复杂性，尤其是涉及到多个父类有相同方法时。

示例：多继承

class Animal:
    def move(self):
        print("Animal moves.")

class Flyer:
    def move(self):
        print("Flies in the air.")

class Bird(Animal, Flyer):
    pass

bird = Bird()
bird.move()  # 输出: Animal moves.

Python 中使用 广度优先 算法来处理方法解析顺序（MRO），因此在继承链中，会优先调用第一个父类中的方法。

1.3 super() 函数

super() 函数用于调用父类的方法，特别是在重写子类中的方法时，可以借助 super() 调用父类的实现。

示例：使用 super() 调用父类方法

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name)  # 调用父类的构造方法
        self.color = color

    def speak(self):
        super().speak()  # 调用父类的 speak 方法
        print(f"{self.name} meows.")

cat = Cat("Whiskers", "Gray")
cat.speak()

2. 抽象类与接口

抽象类是不能被实例化的类，通常用于定义一些通用的接口，子类必须实现这些接口。Python 中可以使用 abc 模块定义抽象类。

2.1 抽象类

通过 abc.ABC 和 @abstractmethod 来定义抽象类及其抽象方法。

示例：定义抽象类

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

    def perimeter(self):
        return 2 * 3.14 * self.radius

circle = Circle(5)
print(circle.area())       # 输出: 78.5
print(circle.perimeter())  # 输出: 31.4

在上面的代码中，Shape 是一个抽象类，定义了 area 和 perimeter 这两个抽象方法，任何继承 Shape 的类必须实现这两个方法。

3. 封装与访问控制

封装是面向对象编程的另一个重要特性，它将数据和方法封装在类的内部，并提供对外的访问接口。Python 中使用命名约定来实现不同层次的封装和访问控制。

3.1 私有属性和方法

在 Python 中，以双下划线 __ 开头的属性或方法会被处理为类的私有属性或方法，无法直接从类外部访问。

示例：私有属性和方法

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

    def get_info(self):
        return f"Name: {self.__name}, Age: {self.__age}"

person = Person("Alice", 30)
print(person.get_info())  # 正常访问
# print(person.__name)    # 会报错，无法直接访问私有属性

Python 通过名称改写机制（name mangling）将私有属性修改为 _ClassName__attribute，因此可以通过这种方式间接访问私有属性，但不建议这样做。

4. 多态

多态是指不同的对象可以以统一的接口调用不同的行为。在 Python 中，多态是通过继承和重写来实现的。

示例：多态

class Animal:
    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def animal_speak(animal):
    print(animal.speak())

dog = Dog()
cat = Cat()

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

无论是 Dog 还是 Cat，它们都继承自 Animal 并重写了 speak 方法。animal_speak() 函数可以接受任何继承 Animal 的实例，这就是多态的应用。

5. 元类

元类是用来创建类的类。在 Python 中，类是对象，而元类就是创建这些类的类。通过元类，开发者可以控制类的创建过程。

5.1 定义元类

可以通过继承 type 来自定义元类，并在类创建时修改类的行为。

示例：自定义元类

class Meta(type):
    def __new__(cls, name, bases, dct):
        print(f"Creating class {name}")
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=Meta):
    pass

# 创建类 MyClass 时，元类 Meta 的 __new__ 方法会被调用
my_instance = MyClass()