---
title: 面对对象
description: Python 面对对象
keywords:
  - Python
  - 面对对象
tags:
  - Python/入门
sidebar_position: 6
author: 7Wate
date: 2023-08-03
---

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式或模型，以「对象」作为核心来设计和实现软件。这种方法主要的目标是将数据和处理数据的函数结合在一起，封装成独立的软件模块，我们称之为「对象」。面向对象编程被广泛应用于多种编程语言中，包括 Python。

## 基本概念

### 理念和用途

**面向对象编程是在更高的抽象层次上思考问题的一种方式。**面向对象编程的主要理念是，将现实世界中的对象抽象化，将对象的属性（也叫状态）和行为（也叫方法）封装在一起。面向对象编程的思考方式，更贴近我们对现实世界的认知。

面向对象编程的主要优点包括：

1. **代码复用性**：类的定义一旦完成，就可以在任何地方创建其对象，复用类的属性和方法，而无需重复编写代码。通过类之间的继承关系，子类可以继承父类的代码，从而实现代码的复用。
2. **代码的可维护性和可扩展性**：面向对象编程的封装特性，保护了对象内部的数据，使得代码更安全，更易于维护。通过类的继承和多态，可以轻松实现对现有代码的扩展。

### 特点

**面向对象编程有三个主要的特点：封装、继承、和多态。**

- **封装**：封装是指将对象的状态（数据）和行为（方法）包装在一起，隐藏对象的内部实现细节，仅对外提供必要的接口。这样可以保护对象的内部状态，提高代码的安全性，也提高了代码的可维护性。
- **继承**：继承是指子类可以继承父类的属性和方法。继承让我们可以在父类的基础上进行扩展，实现代码的复用，提高代码的可扩展性。
- **多态**：多态是指不同类的对象对同一消息会做出不同的响应。多态提供了统一的接口，使得我们可以使用一致的方式处理不同类的对象，提高了代码的灵活性。

## Python 中的类和对象

在 Python 中，我们使用 `class` 关键字来定义类。类是一种数据类型，它定义了一种新的对象，这种对象具有自己的属性和方法。

### 类和对象的概念

- **类 (Class)**： 类是对象的蓝图或原型。你可以想象成是创建对象的模板，它定义了特定类型的对象的属性和方法。

```python
# 一个简单的 Python 类的例子
class Dog:
    pass
```

- **对象 (Object)**：对象是类的实例。具体来说，当我们根据类的定义创建了一个实例后，这个实例就是一个对象。每个对象都具有类定义的属性和方法。

```python
# 创建Dog类的一个实例
my_dog = Dog()
```

我们可以通过创建类的实例，也就是对象，来使用类的属性和方法。

### 类的属性和方法

类的属性和方法是类的主要组成部分。属性用于描述类和其实例的状态，方法用于描述类和其实例可以进行的操作。

在 Python 中，我们可以在类中定义两种类型的属性和方法：

- **实例属性和方法**：实例属性和方法属于类的实例。每个实例都有自己的实例属性，这些属性与其他实例的属性互不影响。实例方法可以通过实例来调用，它可以访问和修改实例的属性。

```python
# 在Python类中定义实例属性和方法的例子
class Dog:
    def __init__(self, name):
        self.name = name  # 实例属性

    def bark(self):  # 实例方法
        return f"{self.name} says woof!"

```

- **类属性和方法**：类属性和方法是属于类本身的，所有的实例都会共享同一个类属性。类方法可以通过类名直接调用，也可以通过实例调用，但是它不能访问和修改实例属性。

```python
# 在Python类中定义类属性和方法的例子
class Dog:
    species = "Canis familiaris"  # 类属性

    @classmethod
    def description(cls):  # 类方法
        return "This class represents a dog."

```

### `__init__`

在 Python 中使用 `__init__` 方法来初始化类的实例。这个方法会在创建实例时自动调用，我们可以在这个方法中设置实例的初始状态，也就是定义实例的属性。

`__init__` 方法的第一个参数始终是 `self`，代表了实例本身。在 `__init__` 方法中，我们使用 `self.属性名` 来定义实例属性。

```python
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
```

## 封装

### 概念和用途

封装，这是面向对象编程（OOP）中的基本概念之一，其目标是通过将数据（对象的状态）和对象的行为组合在一起，来**隐藏或封装对象内部的详细信息**。简单地说，封装就是把客户端代码（对象的使用者）从对象的内部细节中解耦出来。

封装的主要优势包括：

1. **提高了代码的安全性**：封装可以防止对象状态的无意义或不合适的修改。只有通过定义好的方法（有时被称为 getter 和 setter ）才能修改状态，这些方法可以控制对对象状态的更改，从而保证其正确和一致。
2. **提高了代码的可维护性**：由于客户端代码从对象的内部实现中解耦出来，我们可以自由地改变对象的内部实现，而不会影响到使用该对象的代码。

### Python 中实现封装

#### 数据封装

在 Python 中，我们可以通过使用私有属性（私有变量）实现数据封装。**Python 中的私有属性名字前面带有两个下划线（例如 `__name`）。**这些属性只能在类的内部被访问，不能在类的外部直接访问，从而实现了数据的封装。

```python
class Dog:
    def __init__(self, name, age):
        # __name和__age是私有属性，我们不能在类的外部直接访问
        self.__name = name
        self.__age = age
```

#### 方法封装

Python 同样可以通过私有方法实现方法的封装。私有方法的名字也以两个下划线开始，它们只能在类的内部被调用，不能在类的外部直接调用。

```python
class Dog:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    # __bark 是一个私有方法，我们不能在类的外部直接调用
    def __bark(self):
        return f"{self.__name} says woof!"
```

尽管私有属性和方法不能在类的外部直接访问，但是我们可以提供公共的 getter 和 setter 方法，让外部代码能够以受控的方式读写这些私有属性。这样我们就可以保证封装的安全性，同时也提供了一定的灵活性。

```python
class Dog:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    # getter for __name
    def get_name(self):
        return self.__name

    # setter for __name
    def set_name(self, name):
        self.__name = name

    # getter for __age
    def get_age(self):
        return self.__age

    # setter for __age
    def set_age(self, age):
        self.__age = age

    # __bark 是一个私有方法，我们不能在类的外部直接调用
    def __bark(self):
        return f"{self.__name} says woof!"

    # 公共方法可以调用私有方法
    def public_bark(self):
        return self.__bark()
```

## 继承

### 继承的概念和用途

继承是面向对象编程中的核心概念之一。继承允许我们定义一个新的类（子类或派生类）来继承现有类（父类或基类）的属性（变量）和方法（函数）。这样我们就可以在新类中复用父类的代码，避免了代码的重复，同时也可以在新类中添加新的方法或对父类的方法进行重写（override）。

继承的主要优点包括：

1. **代码复用**：子类继承了父类的所有属性和方法，所以我们可以通过创建子类，来复用和扩展父类的代码，减少了代码的重复。
2. **易于维护和修改**：由于子类可以重写父类的方法，这就意味着我们可以在不改变父类的情况下，改变子类的行为。这使得代码更容易维护和修改。

### Python 中实现继承

#### 单继承

在 Python 中，我们可以通过在类定义时的括号中写入父类的名字来创建子类。新定义的类将会继承父类的所有属性和方法。

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

# Dog 是 Animal 的子类，它继承了 Animal 的所有属性和方法。
class Dog(Animal):
    pass
```

#### 多继承

Python 支持多继承，意味着一个类可以继承多个父类。但这可能会导致一些复杂性，如“菱形问题”。

```python
class Swimming:
    def swim(self):
        return "Swims!"

class Flying:
    def fly(self):
        return "Flies!"

class Duck(Swimming, Flying):
    pass

duck = Duck()
print(duck.swim())  # Outputs: Swims!
print(duck.fly())   # Outputs: Flies!
```

#### `super` 函数

在 Python 中，`super` 函数是一个内置函数，它可以用来调用父类的方法。这在你需要在子类中扩展父类的方法时特别有用。

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

# Dog 的 __init__ 方法中使用了 super().__init__(name) 来调用 Animal 的 __init__ 方法。
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # 调用父类的构造方法
        self.breed = breed  # 新增的属性
```

## 多态

### 多态的概念和用途

在面向对象编程（OOP）中，多态性是一种允许一个实体采取多种形态的能力。更具体地说，多态是指通过同一个接口，使用不同的实例，可以产生不同的结果。这使得我们可以在运行时确定我们正在使用的对象类型，然后执行相应的操作。

多态的优势主要有两点：

1. **提高代码的灵活性**：多态能够让我们以更一般的方式编写代码，处理更广泛的数据类型，而不仅仅是特定的单一数据类型。这使得我们的代码更加灵活和可维护。
2. **提高代码的可扩展性**：如果我们想要添加新的数据类型，我们只需要确保它们遵循现有的接口规定。这使得我们的代码更易于扩展和改进，而无需修改大量现有代码。
3. **促进了类之间的解耦**：多态允许系统在不修改现有代码的情况下，添加新的对象类型。

### Python 中实现多态

Python 是一种动态类型语言，意味着我们不需要明确地声明对象的类型。这就让我们在 Python 中能够非常容易地实现多态。以下是 Python 中实现多态的一些方法：

#### 方法重写

在 Python 中，子类可以重写父类的方法。这就意味着，当我们在子类中调用一个父类的方法时，将会执行子类中定义的版本，而非父类中的原始版本。这使得我们可以改变子类中方法的行为，以符合我们的需求。

```python
class Animal:
    def sound(self):
        return "Generic animal sound"

# Dog类重写了Animal类的sound方法，所以当我们调用Dog实例的sound方法时，会返回"Woof!"，而不是"Generic animal sound"。
class Dog(Animal):
    def sound(self):
        return "Woof!"
```

#### Duck Typing

Python 支持一种编程概念叫做 duck typing，这也是实现多态的一种方法。Duck typing 的核心思想是：如果一个对象能够像鸭子一样走路，像鸭子一样叫，那么我们就可以认为它是鸭子。对于 Python 来说，如果一个对象有我们需要的方法，我们就可以使用它，而不管它是什么类型的对象（运行时类型确定）。

```python
def animal_sound(animal):
    # 这个函数只关心对象是否有sound方法，而不关心对象的具体类型
    return animal.sound()

print(animal_sound(Dog()))  # 输出"Woof!"
print(animal_sound(Animal()))  # 输出"Generic animal sound"
```

## 抽象类和接口

### 抽象类和接口的概念

抽象类是一种特殊的类，它不能被实例化，只能被继承。抽象类中可以定义抽象方法，这些方法在抽象类中没有实现，在子类中必须实现。

接口是一种特殊的抽象类，它只定义了一组方法的签名，没有提供任何实现。接口定义了一组行为，任何实现了这些行为的类都可以说是实现了这个接口。

### Python 的 Abc 模块

在 Python 中，我们使用 abc 模块来创建抽象类和接口。abc 模块提供了 `ABC` 基类和 `abstractmethod` 装饰器，我们可以使用它们来定义抽象类和抽象方法。

### Python 中使用抽象类和接口

#### 创建抽象类

我们可以使用 `ABC` 基类和 `abstractmethod` 装饰器来创建抽象类。

```Python
from abc import ABC, abstractmethod

# AbstractAnimal 是一个抽象类，它有一个抽象方法 sound。
class AbstractAnimal(ABC):
    @abstractmethod
    def sound(self):
        pass
```

#### 创建接口

在 Python 中，接口的概念可以通过完全由抽象方法构成的抽象类来实现。与抽象类类似，我们使用 ABC 基类和 abstractmethod 装饰器来定义接口。

```python
from abc import ABC, abstractmethod

# AnimalBehaviour 是一个接口，它定义了两个抽象方法：eat 和 sleep。
class AnimalBehaviour(ABC):
    @abstractmethod
    def eat(self):
        pass

    @abstractmethod
    def sleep(self):
        pass

```

#### 实现接口

我们可以通过继承抽象类并实现其所有的抽象方法来实现接口。

```Python
class Dog(AbstractAnimal, AnimalBehaviour):
    def sound(self):
        return "Woof!"

    def eat(self):
        return "The dog is eating."

    def sleep(self):
        return "The dog is sleeping."
```