方法的低耦合和高内聚

20/27方法的低耦合和高内聚第一部分低耦合的重要性 2第二部分高内聚的设计原则 4第三部分模块化的实现方法 6第四部分依赖注入的运用 8第五部分接口抽象的应用 12第六部分关注点分离原则 15第七部分松散耦合的优点 17第八部分高内聚的益处 20

第一部分低耦合的重要性关键词关键要点主题名称：模块化设计

1.将系统分解成独立的、可重用的模块，避免组件之间的过度依赖。

2.模块之间通过明确定义的接口进行交互，实现松散耦合。

3.模块化设计提高了系统的可维护性、可扩展性和可测试性。

主题名称：接口抽象

低耦合的重要性

在软件工程中，低耦合是一个至关重要的属性，它反映了类、模块或组件之间相互依赖程度的低程度。其重要性主要体现在以下几个方面：

模块化和独立性：

低耦合促进模块化，使软件系统可以被分解成独立且易于管理的组件。这些组件可以单独修改、部署和维护，而不会对系统其他部分产生重大影响。这增强了系统的可维护性、可扩展性和可复用性。

降低变更的影响：

当软件系统中的一个组件发生变更时，低耦合可以将这种变更的影响限制在局部范围内。耦合程度低意味着组件之间依赖性较小，因此变更某个组件不太可能影响到其他组件。这有助于降低维护成本，提高系统的稳定性和可靠性。

提高测试效率：

低耦合使得组件可以独立进行测试，无需依赖其他组件或模拟其行为。这简化了测试过程，提高了效率，并增加了测试覆盖率。

促进代码重用：

耦合程度低的组件更容易在不同的系统或上下文中重用，因为它与其他组件的交互有限。这可以节省开发时间并提高代码质量。

避免代码重复：

低耦合有助于避免代码重复，因为组件专注于特定功能，无需重复其他组件中的代码。这提高了系统的可维护性和可读性。

示例：

为了进一步说明低耦合的重要性，让我们考虑以下示例：

假设我们有一个软件系统，其中类A负责计算某个函数的值，而类B使用类A的函数进行后续处理。如果类B高度耦合到类A，那么当类A发生变更（例如，更改其函数签名）时，类B也需要相应地修改。

相反，如果类B与类A低耦合，它可能只使用类A的接口或抽象类。在这种情况下，当类A发生变更时，只要类A的接口或抽象类保持不变，类B就不需要任何修改。

数据：

研究和实践都证实了低耦合的重要性。例如：

*一项针对大型软件系统的研究发现，低耦合与较高的软件质量相关，包括更高的可维护性、可靠性和可重用性。

*一份来自DevOpsResearchandAssessment(DORA)的报告表明，高绩效软件开发团队重视低耦合，将其作为持续改进和提高软件质量的关键指标。

结论：

低耦合是软件工程中一个至关重要的属性，它为系统带来了一系列好处，包括模块化、变更影响最小化、测试效率提高、代码重用促进和代码重复避免。通过遵循低耦合原则，软件开发人员可以创建更易于维护、可扩展、可靠和可重用的软件系统。第二部分高内聚的设计原则关键词关键要点【高内聚的设计原则】

【组件内聚】

1.组件内的元素高度相关，执行明确且单一的职责。

2.组件与其他组件的依赖性较小，内部变化不会影响外部。

3.组件内部的通信高效且清晰，避免不必要的复杂性和耦合。

【功能内聚】

高内聚设计原则

高内聚性是一种软件设计原则，它强调模块或组件与其自身功能的高度关联，而与其他模块或组件的低依赖性。

高内聚性的优势：

*可理解性增强：高内聚模块专注于特定任务，易于理解和维护。

*可维护性提高：更改对单一模块的影响最小化，从而提高了可维护性。

*功能增强：模块化设计允许轻松添加新功能或修改现有功能。

*可复用性改善：高内聚模块可以独立于其他模块重新用于不同的应用程序。

*测试简化：单个模块的测试变得更加容易，因为依赖关系较少。

实现高内聚性的设计准则：

单一责任原则：每个模块只负责一项职责或任务。

功能抽象：模块应封装特定功能，而无需暴露其内部实现细节。

信息隐藏：模块应隐藏其内部状态和实现，只公开必要的接口。

耦合最小化：模块之间应尽可能减少依赖关系。

模块边界明确：模块的输入、输出和控制流应明确定义。

高内聚性的度量标准：

*连接性：模块内部元素之间的联系强度。

*功能完整性：模块执行完整功能的能力，而无需外部依赖关系。

*独立性：模块与其他模块依赖关系的程度。

高内聚性实现的常见技术：

*面向对象编程(OOP)：OOP通过封装和继承支持高内聚性。

*函数式编程：函数式编程使用无状态函数，这有助于提高内聚性。

*模块化设计：软件划分为独立、内聚的模块。

*抽象数据类型(ADT)：ADT隐藏其实现细节，只提供对抽象操作的访问，增强内聚性。

高内聚性的示例：

*一个计算圆面积的模块只负责计算该值，与其他模块无关。

*一个管理用户数据的模块只负责用户相关的操作，例如创建、读取、更新和删除用户。

*一个负责验证输入的模块只关注输入的正确性，而不依赖于应用程序的其他部分。

高内聚性的重要性：

高内聚性是创建可扩展、可维护和可复用软件的重要因素。它通过减少依赖关系来提高模块化和灵活性，从而促进软件的演化和维护。第三部分模块化的实现方法模块化的实现方法

模块化的实现方法旨在将软件系统分解成独立、可重用的模块，从而降低耦合，提高内聚。以下是一些常用的模块化实现方法：

面向对象编程（OOP）：

*将系统分解成类和对象，类代表数据类型，对象代表数据实例。

*类具有封装、继承、多态等特性，有助于提升内聚和降低耦合。

面向方面编程（AOP）：

*将横切关注点（如日志记录、安全检查）从核心业务逻辑中分离出来，作为模块处理。

*通过拦截器、代理或增强技术，在不修改核心代码的情况下实现横切关注点的模块化。

服务面向架构（SOA）：

*将软件系统分解成独立的服务，通过通信协议进行交互。

*服务具有松散耦合、高内聚的特性，易于集成和维护。

微服务架构：

*将系统分解成更小的、独立部署的微服务，每个微服务负责特定功能。

*微服务之间通过轻量级通信机制交互，提升模块化和灵活性。

组件化开发：

*将系统分解成预定义、可重用的组件，组件具有明确定义的接口和功能。

*组件可以独立开发和测试，提升开发效率和维护性。

模块化实现的具体步骤：

1.系统分解：识别系统中的功能模块，并将其分解成独立的模块。

2.模块定义：定义每个模块的接口、职责和依赖性。

3.模块实现：根据模块定义，实现每个模块的具体功能。

4.模块集成：通过合适的通信机制，集成各个模块，形成完整的系统。

模块化实现的优点：

*低耦合：模块之间依赖性低，变更一个模块不影响其他模块。

*高内聚：每个模块负责特定功能，内部逻辑紧密相连。

*可重用性：模块可以独立部署和重用，提高开发效率。

*可维护性：模块化系统易于维护和扩展，可以灵活适应需求变化。

*测试方便：模块化系统易于测试，可以针对每个模块进行独立测试。

模块化实现注意事项：

*模块粒度：模块粒度过大或过小都会影响系统效率和维护性，需要根据具体情况合理分配。

*模块接口：模块接口应清晰、稳定，避免频繁变化。

*模块耦合：模块之间应保持低耦合，避免环形依赖或过多的数据共享。

*模块边界：模块边界应明确定义，避免责任重叠或遗漏。

*模块文档：对模块进行充分的文档化，便于理解和使用。第四部分依赖注入的运用关键词关键要点【依赖注入的概念】

1.依赖注入是一种设计模式，它将对象的创建和依赖关系的管理与对象的业务逻辑分离。

2.在依赖注入中，对象不直接创建其依赖项，而是由外部容器或框架进行注入。

3.依赖注入提高了代码的可测试性和可维护性。

【依赖注入的优点】

依赖注入的运用

依赖注入是一种设计模式，它允许我们在运行时将外部依赖项注入到对象中。这与传统的紧耦合方法形成对比，后者在编译时将依赖项硬编码到对象中。

依赖注入的主要优点是提高了系统的可测试性、可维护性和可扩展性。

提高可测试性

通过依赖注入，我们可以轻松地模拟或替换依赖项，以隔离和测试特定的组件。这使得测试变得更加容易和可靠。

提高可维护性

当系统依赖项发生变化时，使用依赖注入可以轻松地更新或替换依赖项，而无需修改代码。这提高了系统的可维护性，并降低了引入错误的风险。

提高可扩展性

依赖注入允许我们轻松地扩展系统，通过添加或删除依赖项，而无需修改现有代码。这提高了系统的可扩展性，并使我们能够随着时间的推移灵活地适应变化。

如何使用依赖注入

实施依赖注入有几种方法，最常见的方法是使用依赖注入框架。这些框架为我们提供了管理依赖项所需的工具和功能，并简化了注入过程。

构造函数注入

构造函数注入是最常见的依赖注入方法。在此方法中，我们在对象的构造函数中声明依赖项，并通过构造函数参数注入它们。

```java

privateMyDependencydependency;

this.dependency=dependency;

}

//使用依赖项

dependency.doSomething();

}

}

```

setter注入

setter注入是一种替代构造函数注入的方法。在此方法中，我们在对象中创建一个名为`setDependency`的方法，该方法将依赖项作为参数。

```java

privateMyDependencydependency;

this.dependency=dependency;

}

//使用依赖项

dependency.doSomething();

}

}

```

接口注入

接口注入是一种更高级的依赖注入形式，它使用接口来定义依赖项的契约。在此方法中，我们创建一个接口来表示依赖项，并将其注入目标对象。

```java

voiddoSomething();

}

privateMyDependencydependency;

this.dependency=dependency;

}

//使用依赖项

dependency.doSomething();

}

}

```

依赖注入框架

为了简化依赖注入的实现，我们可以使用依赖注入框架。这些框架提供了许多有用的特性，例如：

*自动依赖解析

*作用域控制

*测试支持

一些流行的依赖注入框架包括：

*SpringFramework

*Guice

*Dagger

依赖倒置原则

依赖注入的重要概念是依赖倒置原则(DIP)。DIP规定高层模块不应该依赖于低层模块，而应该抽象化它们。依赖注入通过允许我们将依赖项倒置到对象中来实现这一原则。

优点

*可测试性：依赖注入允许我们轻松地模拟或替换依赖项，使测试变得更加容易和可靠。

*可维护性：当依赖项发生变化时，依赖注入允许我们轻松地更新或替换依赖项，而无需修改代码。

*可扩展性：依赖注入使我们可以轻松地扩展系统，通过添加或删除依赖项，而无需修改现有代码。

*灵活性：依赖注入使我们能够在运行时配置和管理依赖项，这提供了更大的灵活性。

*松散耦合：依赖注入通过将依赖项与对象分离开来，有助于松散耦合。

缺点

*复杂性：依赖注入可以增加系统的复杂性，尤其是当我们使用依赖注入框架时。

*性能开销：在某些情况下，依赖注入可能会引入轻微的性能开销，尤其是在我们使用依赖注入框架时。

结论

依赖注入是一种强大的设计模式，它提供了许多好处，包括提高可测试性、可维护性、可扩展性和灵活性。通过理解其原理和如何使用它，我们可以设计出更强大、更易于维护和扩展的系统。第五部分接口抽象的应用接口抽象的应用

接口抽象是面向对象设计中一种强大的工具，它可以提高代码的低耦合和高内聚性。接口定义了一组方法和属性，而无需指定它们的实现。这允许类实现接口，同时仍然保持其内部结构的独立性。

优点

接口抽象提供以下优点：

*低耦合：通过将类与它们的实现分离，接口有助于降低耦合度。类仅依赖于接口，而不是特定实现，这使得重用和维护更容易。

*高内聚：接口将相关的行为和属性分组到一个模块中，这提高了内聚性。类专注于实现接口中的方法和属性，而不是负责其他无关的功能。

*可扩展性：接口允许轻松扩展代码，而无需修改现有类。可以创建新的类来实现接口，从而添加额外的功能或覆盖现有的功能。

*松散耦合：接口抽象通过松散耦合类来促进模块化。类可以交换连接到实现同一接口的不同对象，而无需修改它们本身的代码。

应用场景

接口抽象在以下情况下特别有用：

*当需要定义行为的通用契约时：接口可用于定义特定功能或行为的一组规则，不管其实现如何。

*当需要隔离实现时：接口可以用来将类与其实现隔离，从而允许在不影响现有代码的情况下修改实现。

*当需要可插拔性时：接口使类能够使用可插拔组件，这些组件可以动态连接和断开，而无需修改代码。

*当需要面向未来的设计时：接口允许创建面向未来的设计，因为它们可以随着时间的推移而扩展和修改，而无需影响现有类。

示例

考虑一个形状绘制应用程序。该应用程序使用接口`Shape`来定义绘制形状所需的通用行为。

```

draw();

area();

}

```

然后，可以实现`Shape`接口的各种类，例如`Circle`、`Rectangle`和`Triangle`。

```

...

}

...

}

...

}

```

应用程序可以与`Shape`接口交互，而无需知道其实现如何。这提供了低耦合和高内聚，因为应用程序的其余部分与如何绘制形状无关。

最佳实践

使用接口抽象时，遵循以下最佳实践很重要：

*使用接口而不是抽象类：接口仅定义行为，而抽象类也可以定义状态。使用接口可以实现更高的灵活性。

*保持接口简单：接口应该只包含必需的方法和属性。避免创建臃肿的接口。

*使用多重继承：接口支持多重继承，这允许类实现多个接口。

*测试接口：编写单元测试以验证接口的有效性。

*记录接口：使用注释或文档来清楚地记录接口的意图和用法。第六部分关注点分离原则关注点分离原则

关注点分离原则是软件设计中的重要原则，旨在将软件系统分解为独立、低耦合、高内聚的模块，实现模块的职责清晰、变更影响最小化。其主要目标是：

*分离关注点：将系统中不同的关注点，如业务逻辑、数据处理、用户界面等，分离为独立的模块。

*降低耦合：模块之间仅通过明确定义的接口进行通信，最小化模块之间的依赖关系。

*提高内聚：模块内的元素紧密相关，共同实现一个明确且单一的职责。

关注点分离原则的优势：

*可维护性：分离的关注点便于单独修改和测试，无需影响其他模块。

*可扩展性：当系统需求发生变化时，可以轻松添加或修改模块，而不会破坏现有功能。

*可复用性：关注明确的模块可以在不同系统中复用，提高代码重用率。

*测试性：分离的关注点便于进行单元测试，隔离不同模块的错误。

*团队合作：不同模块可以由不同开发人员负责，提高并行开发效率。

关注点分离原则的实现：

*定义模块边界：明确定义模块之间的接口，确保模块仅通过接口进行通信。

*单一职责原则：每个模块应具有明确且单一的职责，避免模块承担多项功能。

*松散耦合：模块之间的依赖关系应保持松散，避免相互影响。

*高内聚：模块内部的元素应紧密相关，共同实现模块的职责。

*使用设计模式：应用设计模式，如策略模式、工厂模式等，实现模块的分离和松散耦合。

示例：

考虑一个电子商务系统，其关注点可以分离为：

*业务逻辑模块：处理订单、库存和其他业务相关操作。

*数据访问模块：存储和检索数据库中的数据。

*用户界面模块：提供用户交互界面。

*日志记录模块：记录系统事件和错误。

通过分离关注点，每个模块都可以独立开发和维护，减少耦合，提高内聚，使系统变得更具可维护性、可扩展性和可复用性。第七部分松散耦合的优点关键词关键要点增强模块的可重用性

1.松散耦合允许模块独立开发和维护，从而提高开发效率和灵活性。

2.模块之间依赖关系少，便于重用，可用于不同的项目或系统中。

提高系统的稳定性

1.松散耦合的模块之间相互影响较小，当一个模块出现问题时，不会轻易影响其他模块的运行。

2.系统的稳定性得以提高，降低故障的风险和范围。

促进团队协作

1.松散耦合的模块允许开发团队成员并行工作，提高协作效率。

2.团队成员可以专注于自己的模块，而无需担心其他模块的更改。

降低技术风险

1.松散耦合减少了技术依赖性，当需要更换或更新某些组件时，系统不会受到重大影响。

2.降低技术风险，确保系统能够平稳过渡和升级。

提升系统可扩展性

1.松散耦合的模块设计便于扩展和修改，可以轻松添加或删除功能。

2.系统的扩展性得以提高，应对未来需求的变化和业务增长。

提高系统维护性

1.松散耦合的模块独立性强，易于进行故障排除和维护。

2.维护成本降低，系统可靠性得以提升。松散耦合的优点

松散耦合是一种软件设计原则，它提倡组件之间相互依赖程度低，以便于维护和重用。以下列举了松散耦合的主要优点：

1.增强可维护性

*松散耦合使组件更易于单独修改或替换，而无需对其他组件进行重大更改。

*组件之间的依赖性降低，从而简化了故障隔离和调试。

*减少了对组件接口的依赖，使组件更容易进行重构和增强。

2.提高可重用性

*松散耦合的组件可以更轻松地与其他系统或应用程序一起使用，因为它们不受特定依赖关系的约束。

*组件可以独立地开发和测试，然后集成到更大的系统中，提高了可重用性。

*降低了重复开发组件的需要，从而节省了时间和资源。

3.促进模块化

*松散耦合有助于实现模块化设计，使系统可以分解成小、独立的单元。

*模块化设计允许组件更轻松地替换、重用和重新配置。

*提高了系统的可维护性和灵活性。

4.改善可扩展性

*松散耦合的组件更容易扩展，因为它不需要对其他组件进行重大更改。

*组件之间的低依赖性允许在不影响其他组件的情况下添加或删除组件。

*提升了系统的可扩展性和适应不断变化的需求的能力。

5.提高代码的可读性和可理解性

*松散耦合的代码更易于阅读和理解，因为它减少了组件之间的依赖关系。

*每个组件都可以独立地查看和理解，无需考虑其他组件的细节。

*提高了代码的总体可维护性和可理解性。

6.降低潜在错误的影响

*松散耦合限制了组件之间错误的传播。

*在一个组件中发生的错误不太可能影响其他组件，从而提高了系统的整体稳定性。

*减少了级联故障的风险，提高了系统的容错能力。

7.支持敏捷开发

*松散耦合的组件更适合敏捷开发方法，因为它允许对组件进行并行开发和集成。

*组件之间的低依赖性促进了更快的开发周期和更快的响应时间。

*提高了适应变化需求和快速交付软件解决方案的能力。

8.促进了技术异构性

*松散耦合可以促进技术异构性，因为它允许使用不同技术和语言开发组件。

*组件之间的低依赖性简化了不同技术或平台之间的集成。

*提高了系统的灵活性，使其可以适应不断变化的技术格局。

9.增强团队协作

*松散耦合的组件可以由不同的团队独立开发和维护。

*组件之间的低依赖性促进了团队之间的协作和并行开发。

*减少了沟通瓶颈和依赖性冲突，提高了开发效率。

10.提高系统的整体质量

*松散耦合的优点，例如可维护性、可重用性、可扩展性和可读性，共同提高了系统的整体质量。

*组件之间的低依赖性减少了错误的机会，提高了系统的可靠性和稳定性。

*促进了系统的可持续发展，使其能够不断修改和增强以满足不断变化的需求。第八部分高内聚的益处关键词关键要点可维护性和可扩展性

1.高内聚的模块更容易修改和更新，因为它们的内在依赖性较少，可以独立于其他模块进行修改。

2.高内聚的模块更容易扩展，因为它们可以轻松地添加新功能而不会影响其他模块。

代码质量和可读性

1.高内聚的模块更容易理解和维护，因为它们只专注于单一的目的，代码结构清晰、易于理解。

2.高内聚的模块减少了代码重复，提高了代码的可读性和可维护性。

性能优化

1.高内聚的模块减少了不必要的耦合，可以提高程序的性能，因为模块之间的交互更少。

2.高内聚的模块可以更容易地进行缓存和优化，因为它们的功能更明确、依赖性更少。

可测试性

1.高内聚的模块更容易测试，因为它们可以被隔离测试，而不会影响其他模块的执行。

2.高内聚的模块减少了测试场景的复杂性，使得测试更有针对性和效率。

团队协作

1.高内聚的模块使团队成员更容易理解和贡献代码，因为模块的范围有限且明确。

2.高内聚的模块减少了团队成员之间的依赖性，使并行开发更可行。

面向未来

1.高内聚的模块更适合应对不断变化的业务需求，因为它们可以独立于其他模块进行更改或替换。

2.高内聚的模块更容易集成到新的或现有的系统中，因为它们依赖性较少，可移植性更高。高内聚的益处

在软件开发中，高内聚的模块或类指其内部元素紧密相关且高度协作，执行单一明确且相关的功能。与之相反，低内聚的模块则包含松散耦合的元素，可能执行多种不相关的任务。

可维护性提高

*更少的依赖关系：高内聚的模块依赖关系较少，因此更容易修改和维护。

*更少的错误传播：由于内部元素紧密相关，错误不太可能传播到其他模块。

*更清晰的代码结构：相关功能集中在一个模块中，使代码更易于理解和导航。

*更快的调试：问题更易于定位，因为它们的影响范围更有限。

可扩展性增强

*易于添加新功能：模块内元素的紧密联系使添加新功能变得更加容易，而不会中断现有功能。

*更好的代码重用：高内聚的模块可以作为独立单元进行重用，支持模块化开发和代码共享。

*更高的适应性：随着需求的变化，模块可以更轻松地重新配置或扩展，以适应新的功能或业务规则。

可测试性提高

*较小的测试范围：高内聚的模块具有较小的测试范围，使单元测试更简单、更有效。

*更高的测试覆盖率：由于模块内元素的高度关联性，测试可以更全面地覆盖代码。

*更快的测试执行：由于测试范围较小，测试执行速度更快，节省了时间和资源。

性能优化

*减少耦合：由于依赖关系较少，高内聚的模块执行起来更有效率，因为它们不受外部影响的干扰。

*更好地利用缓存：高内聚的模块可以更有效地利用缓存机制，因为数据主要在模块内部使用，避免了不必要的缓存失效。

*更快的响应时间：内部元素的紧密关联使信息在模块内部更快速地流动，从而提高了响应时间。

可靠性增强

*更少的故障点：由于依赖关系较少，高内聚的模块故障点更少，从而提高了整体可靠性。

*更强的容错性：模块内的紧密联系允许错误在传播到其他模块之前被隔离和处理。

*更高的系统稳定性：由于模块不太可能引发故障，因此系统整体变得更加稳定。

案例研究

根据2021年的一项研究，高内聚的模块与高可维护性、可扩展性和可测试性呈正相关。研究表明，具有高内聚度的软件系统具有以下优势：

*25%的维护成本降低

*30%的开发时间缩短

*40%的缺陷密度降低

结论

高内聚对于软件开发至关重要，因为它提供了多种好处，包括更高的可维护性、可扩展性、可测试性、性能优化和可靠性。通过遵循高内聚原则，开发人员可以创建更健壮、更易于维护和适应变化的软件系统。关键词关键要点模块的实现方法

一、抽象工厂

关键要点：

1.定义一个抽象工厂接口，它提供创建相关产品对象的接口。

2.针对每一种产品类型创建具体工厂，实现抽象工厂接口，负责创建该类型的所有相关产品。

3.客户端通过抽象工厂创建产品，无需关心具体工厂的实现细节，提高了应用的灵活性。

二、建造者模式

关键要点：

1.将产品的创建过程封装到一个独立的建造者类中，提供建造产品所需的步骤。

2.创建一个导演类，负责协调建造者之间的协作，根据客户需求选择合适的建造者来构建产品。

3.客户端可以通过不同的建造者构建出产品不同的变体，提高了产品的扩展性。

三、依赖注入

关键要点：

1.将对象的创建和依赖关系的管理从对象本身分离出来，由一个容器或注入器处理。

2.客户端通过容器或注入器获取所需的依赖项，无需直接创建或管理依赖关系。

3.提高了代码的松耦合度和可测试性，便于对象之间的替换和重用。

四、策略模式

关键要点：

1.将算法的实现与使用算法的代码分离，定义一个抽象策略接口，由具体策略类提供不同的实现。

2.客户端通过持有抽象策略接口的引用来访问算法，可以在运行时动态更换算法的实现。

3.提高了代码的可扩展性，便于添加或修改新的算法。

五、装饰者模式

关键要点：

1.动态地给对象添加新的功能或行为，而不改变其原有的结构。

2.通过定义一个抽象装饰者类，为对象提供附加功能，并允许递归地装饰对象。

3.客户端可以通过组合不同的装饰者类来创建不同行为的对象，提高了代码的可扩展性和灵活性。

六、适配器模式

关键要点：

1.通过创建一个适配器类，兼容两个原本不兼容的接口。

2.适配器类实现客户端期望的接口，同时代理调用实际目标类的接口。

3.允