面向对象编程（4）——接口与实现-CSDN博客

接口关注的是“做什么”，而不是“怎么做”。它允许不同的类以不同的方式实现相同的接口，使得代码可以处理这些对象时无需了解其具体类型。在许多编程语言中，接口可以用专门的关键字定义，如 Java 中的 interface 或 Python 中的抽象基类（ABC）。然而，在更广泛的意义上，接口也可以只是类公开的那些方法和属性的集合。

1.2 实现

实现是指接口所描述的操作的具体执行方式。它是类的内部细节，决定了类在接收到特定请求时如何响应。实现的主要目的是提供具体的行为和功能，是接口在特定上下文中的具体化。

实现关注的是“怎么做”，即通过具体的算法和数据结构实现接口定义的行为。实现细节通常是封装的，避免外部直接访问。这种封装有助于保护对象的内部状态和数据完整性。实现可以在不改变接口的情况下被修改或替换，从而提高系统的灵活性和适应性。

1.3 示例

以下是一个简单的例子，用于说明接口与实现之间的关系：

from abc import ABC, abstractmethod

# 定义接口
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# 实现具体的类
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

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

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side ** 2

# 使用接口来操作对象
def print_area(shape: Shape):
    print(f"The area is: {shape.area()}")

circle = Circle(5)
square = Square(4)

print_area(circle)  # 输出: The area is: 78.5
print_area(square)  # 输出: The area is: 16

在这个例子中，Shape 是一个接口，定义了 area 方法，而 Circle 和 Square 是实现了 Shape 接口的具体类。Circle 和 Square 提供了 area 方法的具体实现。通过接口 Shape，我们可以使用 print_area 函数来计算和打印任何实现了 Shape 接口的对象的面积，而无需关心它们的具体类型。

二、暴露情况

在面向对象编程中，接口和实现并不都是对外暴露的。它们代表了系统的两个不同层面，通常有不同的访问控制策略。

2.1 接口暴露情况

接口通常是对外公开的，它定义了类的公共方法和属性，即外部代码可以调用的功能。接口的目的是提供一个统一的操作契约，让外部代码可以使用类的功能而不需要了解其内部实现。接口中的方法和属性是可调用和可访问的。它们是类与外部系统交互的主要途径。通过接口，类向外部暴露了它能够提供的服务或行为。

接口最小化

但是在实际的设计的过程中，我们不应该过多的运用接口，最好的做法是只保留必要的接口，遵从接口最小化原则。接口最小化（Minimization of Interfaces）是面向对象设计中的一个重要原则，它强调设计类或模块的公共接口时，应只暴露最少的、必要的功能。这一原则有助于减少类或模块的复杂性，提高其安全性和可维护性。

降低复杂性：一个小而精简的接口可以减少使用者的学习成本，使得类或模块更易于理解和使用。
增强安全性：最小化接口可以限制外部访问类的内部状态和行为，减少错误使用的风险，同时保护类的内部实现细节，避免不必要的依赖。
提高灵活性：通过限制接口暴露的功能，可以在不影响使用者的情况下更改类的内部实现细节。这种封装使得类更容易维护和更新。
促进职责单一原则：接口最小化鼓励类只提供特定的、明确的功能，有助于保持类的职责单一，从而提高代码的模块化和可测试性。

实现方式：

暴露必要功能：只在公共接口中暴露那些对于类的使用者来说确实必要的功能。其他功能应保持私有或受保护，以防止外部访问。

慎用访问器和修改器：虽然访问器（getter）和修改器（setter）方法可以控制对属性的访问，但过度暴露这些方法可能会导致接口臃肿。应考虑是否有必要提供对内部状态的直接访问，或是否可以通过其他方式满足需求。

接口分离：将不同的功能分离到不同的接口中，而不是在一个接口中包含所有功能。这种做法使得实现类可以选择实现部分接口，避免暴露过多功能。

接口文档化：清晰地文档化接口的目的、使用方法和限制，有助于使用者理解如何正确使用类的功能，避免误用。

class Account:
    def __init__(self, owner, balance=0):
        self.__owner = owner
        self.__balance = balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return True
        return False

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            return True
        return False

    def get_balance(self):
        return self.__balance

    def get_owner(self):
        return self.__owner

在这个例子中，Account 类的接口只暴露了存款、取款、获取余额和获取账户持有人这几个方法，而余额和持有人的属性则被标记为私有。这种设计避免了外部直接修改这些敏感数据，保持了类的内聚性和数据安全性。接口最小化是构建健壮、可维护软件系统的重要策略。通过限制公共接口的大小和复杂性，开发者可以更好地控制类的使用方式，防止滥用，确保系统的健壮性和安全性。

2.2 实现暴露情况

实现细节通常不对外暴露。类的实现部分包括私有的（private）和受保护的（protected）方法和属性，它们是类的内部机制，不应被外部直接访问。这种封装有助于保护对象的内部状态，防止外部代码直接操作或依赖于内部实现。虽然从技术上讲，所有类的代码（包括实现部分）在类内部是可调用的，但实现的很多部分（如私有方法和属性）对外部代码是不直接可见或可调用的。这是为了保持类的封装性和内部状态的一致性。

在面向对象编程中，私有实现和私有属性是指类中的成员不对外暴露，只供类的内部使用。区分和使用私有实现和属性的方式通常依赖于编程语言的语法和约定。

2.2.1 区分私有实现和属性

（1）命名约定：这是最常见的方法，通过特定的命名约定来标识私有成员。

单下划线 _ 前缀：在 Python 中，通常用单个下划线前缀来表示属性或方法是受保护的（虽然不是真正的私有），如 _attribute 或 _method。这是一个约定，意味着这些成员不应在类外部使用。
双下划线 __ 前缀：Python 使用双下划线前缀来表示私有成员，如 __attribute 或 __method。这种命名方式会触发名称改编（name mangling），将其转换为 _ClassName__attribute 的形式，以避免子类和外部访问。
无下划线或公有命名：没有下划线的成员默认是公共的，可以被外部访问。

（2）访问控制修饰符：一些编程语言使用关键字来明确指定访问级别，如 private、protected 和 public。

private：私有成员，只能在类内部访问。在 C++、Java 等语言中，private 关键字用于声明私有属性和方法。
protected：受保护成员，可以在类内部和子类中访问，但不能在类外部访问。这种修饰符在 C++、Java 等语言中存在。
public：公共成员，可以在任何地方访问。

在Python中，访问控制主要通过命名约定来实现，这些约定是社区广泛认可和遵循的惯例，而不是由编译器强制执行的规则。

1. 单下划线 `_` 前缀

在Python中，使用单下划线前缀来命名属性和方法（如 _attribute 或 _method），表示这些成员是“受保护”的，意味着它们不应在类外部直接访问。这种做法更多是一种约定，而非强制性规则。Python不会阻止外部访问带有单下划线前缀的成员，但这一约定提醒开发者这些成员是内部实现的一部分，不属于类的公共接口。

2. 双下划线 `__` 前缀

使用双下划线前缀（如 __attribute 或 __method）可以触发Python的名称改编（name mangling）机制。名称改编会将属性和方法的名称改为 _ClassName__attribute 的形式，从而使得这些成员在外部难以访问。这在一定程度上提供了更强的保护，避免子类和外部代码无意中访问和修改这些私有成员。然而，这种机制同样不是完全的访问控制，因为名称改编后的属性仍然可以通过特定的名字访问，只是外部不应这样做。

3. 编译器的角色

Python是一种动态类型的解释型语言，它的解释器并不像一些编译型语言的编译器那样严格 enforce（强制执行）访问控制。Python的设计哲学之一是“我们都成年人了”（We are all consenting adults here），这意味着它更依赖于开发者的自律和良好实践，而不是语言本身来强制限制访问。

4. 总结

在Python中，使用下划线前缀的访问控制机制更多是一种基于约定的策略，而不是由编译器严格执行的规则。这种约定帮助开发者区分公共接口和内部实现，并提供了一定的保护，防止无意的错误访问。对于公共接口的设计和私有实现的隐藏，开发者应遵循这些惯例来确保代码的可读性和维护性。

以下是一个Python类的示例，其中展示了如何使用单下划线和双下划线来区分公共、受保护和私有属性和方法。这些示例遵循了Python社区的惯例，而非编译器强制的规则。

class ExampleClass:
    def __init__(self, public_data, protected_data, private_data):
        self.public_data = public_data          # 公共属性
        self._protected_data = protected_data  # 受保护属性
        self.__private_data = private_data     # 私有属性

    def public_method(self):
        """公共方法，可以在类外部调用"""
        return f"Public data: {self.public_data}"

    def _protected_method(self):
        """受保护的方法，通常不应在类外部调用"""
        return f"Protected data: {self._protected_data}"

    def __private_method(self):
        """私有方法，不应在类外部调用"""
        return f"Private data: {self.__private_data}"

    def access_private(self):
        """类内部访问私有方法"""
        return self.__private_method()

# 创建对象
example = ExampleClass("Public", "Protected", "Private")

# 访问公共属性和方法
print(example.public_data)          # 输出: Public
print(example.public_method())      # 输出: Public data: Public

# 访问受保护属性和方法（虽然可以访问，但不推荐在外部使用）
print(example._protected_data)      # 输出: Protected
print(example._protected_method())  # 输出: Protected data: Protected

# 访问私有属性和方法（直接访问会导致 AttributeError）
try:
    print(example.__private_data)
except AttributeError as e:
    print(e)  # 输出: 'ExampleClass' object has no attribute '__private_data'

try:
    print(example.__private_method())
except AttributeError as e:
    print(e)  # 输出: 'ExampleClass' object has no attribute '__private_method'

# 通过类内方法访问私有数据
print(example.access_private())     # 输出: Private data: Private

# 使用名称改编（name mangling）访问私有属性和方法（不推荐）
print(example._ExampleClass__private_data)    # 输出: Private
print(example._ExampleClass__private_method())  # 输出: Private data: Private

公共属性和方法：public_data 和 public_method 是类的公共接口，可以在类的外部自由访问和调用。

受保护属性和方法：_protected_data 和 _protected_method 使用单下划线前缀表示受保护。虽然外部仍然可以访问它们，但这是一种约定，表示这些成员不应在类的外部使用。

私有属性和方法：__private_data 和 __private_method 使用双下划线前缀，触发名称改编机制，使它们在类外部不易访问。试图直接访问这些私有成员会导致 AttributeError。

名称改编访问：虽然 Python 允许通过名称改编后的名字（如 _ExampleClass__private_data）访问私有成员，但这种做法违背了封装的意图，一般不推荐使用。

类内访问私有成员：类内部仍可以自由地访问私有属性和方法，这保证了封装的同时，也允许类内实现复杂的逻辑和数据管理。