【UML】NO.2 UML必须了解的基础知识（举例）

目录

一、UML的构成

1.1 事物

1.2 关系

1.3 图

二、事物

2.1 结构事物

2.1.1 类（class）

2.1.2 接口

2.1.3 协作

2.1.4 用例

2.1.5 主动类

2.1.6 构件

2.1.7 节点

2.2 行为事物

2.2.1 交互

2.2.2 状态机

2.2.3 活动

2.3 分组事物

包

2.4 注释事物

三、关系

3.1 依赖关系

3.2 关联关系

3.3 泛化关系

3.4 实现关系

四、公共机制

---

学些UML，首先要知道，UML包括哪些主要构成元素。

建议大家收藏本文，后续我会补画例子的图示，一站式学习。        

一、UML的构成

UML的构成包括了事物、关系和图三个部分。以下是它们的详细解释：

1.1 事物

UML中的事物也称为建模元素，包括结构事物、行为事物、分组事物和注释事物。

• 结构事物：描述系统中静态结构的元素，包括类、接口、协作、用例、主动类、节点和组件等。
• 行为事物：描述系统中动态行为的元素，包括状态机和交互等。
• 分组事物：描述如何将一组结构事物和行为事物组织在一起，形成一个更大的单位，这就是包。
• 注释事物：用于对模型中的元素进行解释和说明，这就是注释。

1.2 关系

UML中的关系描述了事物之间的联系，包括关联关系、泛化关系、实现关系和依赖关系。

• 关联关系：描述两个类之间的结构关系，包括聚合和组合两种形式。
• 泛化关系：描述类之间的继承关系，表示一个类是另一个类的特殊情况或类型。
• 实现关系：描述类实现接口的情况。
• 依赖关系：描述两个模型元素之间的语义关系，其中一个元素（独立元素）发生变化会影响另一个元素（依赖元素）的语义。

1.3 图

UML中的图描述了系统的一个方面或视角，包括静态图和动态图两种。

• 静态图：包括类图、对象图、包图、组件图和部署图等，用于描述系统的静态结构。
• 动态图：包括用例图、活动图、状态图、交互图（包括顺序图、通信图和时序图）等，用于描述系统的动态行为。

以上就是UML的构成部分及其解释。这些元素共同构成了UML的基础，使得我们可以使用UML对软件进行建模和分析。

如果只想了解大概，那么上面就是核心干货了。如果想具体了解，请继续阅读。

二、事物

2.1 结构事物

2.1.1 类（class）

在UML中，类是一种基本的建模元素，它描述了具有相同属性、操作、关系和语义的一组对象的集合。类定义了一组对象的所有属性和行为。

类的定义通常包括以下几个部分：

• 类名：用于标识类的名称，通常采用驼峰命名法。
• 属性：类的属性描述了类的状态，即对象所包含的数据。每个属性都有一个名称、类型和可见性（如公有、私有或受保护的）。
• 操作：类的操作描述了类可以执行的行为，即对象的方法或函数。每个操作都有一个名称、参数列表和返回类型。操作也可以具有可见性。
• 关系：类可以与其他类建立关系，如关联关系、泛化关系、实现关系和依赖关系。这些关系描述了类之间的交互和联系。

例如，考虑一个简单的“狗”类，它可能具有以下定义：

类名：Dog

属性：

• name (String): 狗的名字
• age (int): 狗的年龄
• breed (String): 狗的品种

操作：

• bark(): 狗叫
• run(): 狗跑
• eat(food: Food): 狗吃食物

这个“狗”类定义了一个具有三个属性和三个操作的类。在实际编程中，这个类可以被实例化为一个或多个“狗”对象，每个对象都具有自己的属性和行为。

在UML类图中，类通常用一个矩形表示，类名放在矩形的顶部，属性和操作分别放在矩形的中部和底部。属性和操作之前可以加上可见性修饰符（+ 表示公有，- 表示私有，# 表示受保护的）。关系通常用线连接相关的类，并在线上标上关系的名称。

2.1.2 接口

在UML中，接口（Interface）是一种特殊的类，它定义了一组操作的规范，但没有实现这些操作。接口描述了类应该具备的行为，但并不关心如何实现这些行为。接口定义了一种契约，规定了类必须遵守的行为规则。

接口的定义通常包括以下几个部分：

• 接口名：用于标识接口的名称，通常采用驼峰命名法。
• 操作：接口的操作是它所定义的一组方法或函数的集合。每个操作都有一个名称、参数列表和返回类型。与类不同，接口只定义操作的签名，而不提供具体的实现。

例如，考虑一个简单的“可绘制”接口，它可能具有以下定义：

接口名：Drawable

操作：

• draw(): 绘制对象

这个“可绘制”接口定义了一个具有一个操作的接口，即“绘制对象”。任何实现了这个接口的类都必须提供“draw()”方法的具体实现。

在实际编程中，接口可以被类实现（implement），这意味着类必须提供接口中定义的所有操作的具体实现。一个类可以实现多个接口，这意味着它需要提供多个接口中定义的操作的实现。

在UML类图中，接口通常用一个带有《interface》标签的矩形表示，接口名放在矩形的顶部，操作列在矩形的底部。与类不同，接口没有属性部分。实现关系通常用一条带有虚线的线连接实现接口的类和接口本身，线上标上“implements”或“<>”等关键字。

使用接口的好处之一是它们提供了一种抽象层，允许不同的类实现相同的接口，从而实现多态性。这意味着可以使用相同的接口引用不同的对象，并在运行时确定实际执行的操作。这种灵活性使得接口成为面向对象编程中一种重要的工具，用于定义和扩展系统的行为。

2.1.3 协作

在UML中，协作（Collaboration）是指多个类、接口或其他建模元素之间为了完成特定任务而进行的交互和合作。协作描述了不同建模元素之间的关系以及它们在实现共同目标时的行为。

协作的定义通常包括以下几个部分：

• 参与者：协作涉及多个参与者，这些参与者可以是类、接口、对象或其他建模元素。每个参与者在协作中扮演特定的角色，并与其他参与者进行交互。
• 交互：协作中的交互是指参与者之间传递消息、调用操作或共享信息的过程。这些交互可以是同步的或异步的，并且可以包括各种行为，如方法的调用、事件的触发或数据的传递。
• 关系：协作中的关系描述了参与者之间的联系和依赖。这些关系可以是关联关系、泛化关系、实现关系、依赖关系或其他UML定义的关系。关系定义了参与者之间如何进行交互和合作。
• 场景：协作通常发生在特定的场景中，即一组特定的条件和环境下。场景描述了协作发生的原因、参与者的状态以及它们之间的交互序列。

例如，考虑一个简单的在线购物系统，其中包括顾客、购物车和订单等类。在这个系统中，顾客可以将商品添加到购物车中，然后将购物车中的商品生成订单。这个过程涉及多个类之间的协作。

参与者：

• 顾客（Customer）：表示系统中的用户，具有浏览商品、添加商品到购物车和生成订单等行为。
• 购物车（ShoppingCart）：表示顾客的购物车，具有添加商品、移除商品和计算总价等行为。
• 订单（Order）：表示顾客生成的订单，具有保存订单信息和处理支付等行为。

交互：

• 顾客浏览商品并将选中的商品添加到购物车中。
• 顾客将购物车中的商品生成订单。
• 订单处理支付并保存订单信息。

关系：

• 顾客与购物车之间存在关联关系，顾客可以拥有多个购物车，但每个购物车只能属于一个顾客。
• 购物车与订单之间存在泛化关系，订单是购物车的特化形式，继承了购物车的一些属性和行为。

这个简单的在线购物系统示例展示了类之间的协作，描述了它们在完成购物过程中的交互和合作方式。在实际的UML建模中，可以使用顺序图、通信图或活动图等来可视化和描述协作的详细过程。

UML中的协作描述了多个建模元素之间为了完成特定任务而进行的交互和合作，它涉及参与者、交互、关系和场景等元素。通过理解和建模协作，可以更好地理解系统的动态行为并设计有效的软件解决方案。

2.1.4 用例

在UML中，用例（Use Case）是一种描述系统功能的模型元素，它代表了一个系统、子系统或类与外部用户或其他系统之间的交互行为。用例捕获了系统应该执行的功能性需求，并描述了系统如何与外部实体进行交互以实现这些功能。

用例的定义通常包括以下几个部分：

• 用例名：用于标识用例的名称，应该简洁明了地描述用例的主要功能。
• 参与者：与用例进行交互的外部实体，可以是用户、其他系统或硬件设备。参与者描述了与用例相关的角色和责任。
• 前置条件：执行用例之前必须满足的条件或状态。这些条件限制了用例的执行，并确保在执行用例之前系统处于适当的状态。
• 主成功场景：描述了用例的主要成功路径，即正常情况下用例的执行过程。主成功场景应该清晰地描述参与者与系统之间的交互步骤和结果。
• 扩展和异常场景：描述了用例的扩展路径和异常情况下的执行过程。这些情况包括错误处理、异常输入或异常状态等。扩展和异常场景提供了对主成功场景的补充和异常情况的处理方式。

例如，考虑一个简单的在线图书馆系统，其中包括用户登录、浏览书籍、借阅书籍和归还书籍等功能。下面是一个关于“借阅书籍”功能的用例示例：

用例名：借阅书籍

参与者：图书馆用户

前置条件：用户必须已经登录并且具有借阅权限。

主成功场景：

• 用户选择想要借阅的书籍。
• 系统检查书籍的可用性和用户的借阅权限。
• 如果书籍可用且用户有权限，系统将书籍状态更新为“已借出”，并将借阅信息保存到用户的借阅记录中。
• 系统显示借阅成功的消息。

扩展和异常场景：

• 如果书籍不可用，系统显示书籍不可借的消息，并允许用户选择其他书籍。
• 如果用户没有借阅权限，系统显示权限不足的消息，并终止借阅流程。

这个示例展示了用例如何描述系统的功能性和交互行为。通过定义用例，我们可以更好地理解系统的需求和行为，并在设计和开发过程中确保满足用户的期望和需求。在实际的UML建模中，可以使用用例图来可视化和组织用例之间的关系，以便更好地理解和沟通系统的功能需求。

2.1.5 主动类

在UML中，主动类（Active Class）是一种具有生命周期并能主动启动和控制其行为的类。它描述了对象具有并发行为和独立控制流的情况。主动类具有与传统类相似的结构，但它们能够接收和处理事件，拥有自身的线程，并与其他主动类进行并发交互。

主动类的定义通常包括以下几个部分：

• 类名和属性：主动类具有与传统类相同的类名和属性定义。它们可以包含状态信息和其他数据成员。
• 行为：主动类的行为由其操作（方法）和状态机来描述。操作定义了主动类可以执行的行为，而状态机描述了主动类在不同状态下的行为以及状态之间的转换。
• 并发性：主动类具有并发性特征，它们可以创建自己的线程并在执行过程中与其他线程进行交互。这意味着主动类的对象可以在同一时间内执行多个操作。
• 事件处理：主动类能够接收和处理外部事件。当事件发生时，主动类的对象会触发相应的操作或状态转换来响应事件。

例如，考虑一个简单的电梯控制系统，其中电梯是一个主动类。每个电梯对象具有自身的状态（如开门、关门、上升、下降等），并且能够响应乘客的按钮按下事件。

类名：Elevator

属性：

• currentFloor：当前所在楼层
• targetFloor：目标楼层
• state：电梯的状态（开门、关门等）

行为：

• openDoor()：打开电梯门
• closeDoor()：关闭电梯门
• moveUp()：电梯上升一层
• moveDown()：电梯下降一层

并发性：
电梯对象具有自身的线程，可以在不同的时间点接收和处理多个乘客的按钮按下事件。

事件处理：
当乘客按下按钮时，电梯对象会触发相应的操作来改变其状态和目标楼层，并启动移动过程。

这个示例展示了主动类如何描述具有生命周期、并发行为和事件处理能力的对象。通过定义主动类，我们可以更好地理解和建模具有并发和反应性的系统，并在设计和开发过程中考虑并发和同步的问题。在实际的UML建模中，可以使用状态图和顺序图等来可视化和描述主动类的行为和交互。

2.1.6 构件

在UML中，构件（Component）是软件系统中的可替换的物理部件，它封装了实现，并通过一组接口与外部环境进行交互。构件代表了在部署和运行时环境中可观察到的物理元素，例如可执行文件、库、框架或插件。

构件的定义通常包括以下几个部分：

• 名称和类型：每个构件都有一个唯一的名称和类型，用于标识和分类构件。类型可以是可执行文件、库文件或其他二进制文件等。

• 接口：构件通过接口与外部环境进行交互。接口定义了构件提供的服务或操作，并指定了与其他构件或系统元素的交互方式。

• 实现：构件封装了具体的实现细节，这些实现细节可以是源代码、二进制代码或其他形式的实现逻辑。

• 依赖关系：构件之间可能存在依赖关系，表示一个构件依赖于另一个构件的服务或功能。这些依赖关系可以是编译时依赖或运行时依赖。

例如，考虑一个简单的Web应用程序，其中包括前端和后端组件。前端组件负责用户界面和交互逻辑，而后端组件负责数据处理和业务逻辑。每个组件都可以被视为一个构件。

在这个示例中，前端组件可以是一个Web浏览器中的JavaScript文件，它提供了用户界面和交互功能。后端组件可以是一个Web服务器上的Java应用程序，它处理来自前端的请求并返回相应的数据。

前端构件（Frontend Component）：

• 名称：Frontend.js
• 类型：JavaScript文件
• 接口：提供了用户界面和交互功能的API
• 实现：封装了前端逻辑和交互的JavaScript代码

后端构件（Backend Component）：

• 名称：Backend.jar
• 类型：Java应用程序
• 接口：提供了数据处理和业务逻辑的API
• 实现：封装了后端逻辑和数据处理的Java代码

这些构件通过HTTP协议进行交互。前端构件发送HTTP请求给后端构件，并接收后端构件返回的HTTP响应。这种交互方式定义了构件之间的接口和依赖关系。

在实际的UML建模中，可以使用组件图（Component Diagram）来可视化和描述构件之间的关系和依赖。组件图显示了系统中不同构件之间的连接和交互方式，并提供了关于构件物理组织和部署的信息。

UML中的构件是软件系统中的物理部件，它封装了实现并通过接口与外部环境进行交互。通过定义构件，我们可以更好地理解和组织软件系统的物理结构，并确保在不同环境中正确部署和运行软件系统。

2.1.7 节点

在UML中，节点（Node）表示运行时环境中的物理或逻辑资源，它是系统部署和执行的基本单位。节点可以是计算机、服务器、设备或其他具有处理、存储和通信能力的实体。节点描述了系统的物理拓扑结构以及在这些节点上运行的软件组件。

节点的定义通常包括以下几个部分：

• 名称和类型：每个节点都有一个唯一的名称和类型，用于标识和分类节点。类型可以是计算机、服务器、设备等。
• 计算资源：节点具有计算资源，包括处理器、内存、存储设备等。这些资源用于执行和存储软件组件。
• 软件组件：节点上可以部署和运行一个或多个软件组件，包括应用程序、中间件、操作系统等。这些组件与节点的计算资源进行交互，实现系统的功能。
• 连接关系：节点之间通过连接进行通信和数据传输。连接关系可以是网络连接、通信协议或其他形式的连接。

例如，考虑一个简单的分布式系统，其中包括Web服务器、数据库服务器和客户端节点。每个节点都具有不同的功能和资源，并通过网络连接进行交互。

在这个示例中，Web服务器节点负责处理Web请求和生成响应，数据库服务器节点负责存储和管理数据，而客户端节点则是用户与系统交互的接口。

Web服务器节点（Web Server Node）：

• 名称：WebServer
• 类型：服务器
• 计算资源：处理器、内存、存储设备
• 软件组件：Web服务器软件（如Apache）、应用程序代码等

数据库服务器节点（Database Server Node）：

• 名称：DatabaseServer
• 类型：服务器
• 计算资源：处理器、内存、存储设备
• 软件组件：数据库管理系统（如MySQL）、数据存储等

客户端节点（Client Node）：

• 名称：Client
• 类型：计算机或设备
• 计算资源：处理器、内存、显示设备等
• 软件组件：客户端应用程序（如Web浏览器）等

这些节点通过网络连接进行交互，Web服务器节点接收来自客户端节点的请求，并与数据库服务器节点进行通信以获取数据。这种交互方式定义了节点之间的连接关系和数据传输方式。

在实际的UML建模中，可以使用部署图（Deployment Diagram）来可视化和描述节点之间的关系和连接。部署图显示了系统中不同节点的物理拓扑结构以及在这些节点上运行的软件组件的部署情况。它提供了关于系统如何在实际环境中部署和执行的信息。

总结而言，UML中的节点表示运行时环境中的物理或逻辑资源，描述了系统的物理拓扑结构和软件组件的部署情况。通过定义节点，我们可以更好地理解系统的实际部署和执行环境，并确保软件组件在正确的位置运行并与其他组件进行正确的交互。

2.2 行为事物

2.2.1 交互

在UML中，交互（Interaction）描述了对象之间为完成特定任务而进行的通信和协作。交互强调了在系统执行过程中对象之间的动态行为，包括消息传递、操作调用和状态变化等。交互是UML中用于描述系统动态行为的重要概念之一。

交互的定义通常包括以下几个部分：

• 对象：交互涉及的对象是系统中的类或实例。这些对象可以是系统中的参与者、控制器、业务逻辑等。
• 消息：消息是对象之间进行通信的基本单位。消息可以是操作调用、事件触发或其他形式的通信。消息传递描述了对象之间的协作和交互方式。
• 顺序：交互中的对象按照一定的顺序发送和接收消息。顺序描述了交互的时序和逻辑流程。
• 场景：交互发生在特定的场景中，例如用户操作、系统响应、异常处理等。场景定义了交互的上下文和目的。

例如，考虑一个简单的在线购物系统，其中包括用户、购物车和订单等对象。用户浏览商品并将商品添加到购物车中，然后提交订单进行结算。这个过程涉及多个对象之间的交互。

在这个示例中，用户对象发送消息给购物车对象，将商品添加到购物车中。购物车对象更新状态并返回确认消息给用户对象。然后，用户对象发送提交订单的消息给订单对象，订单对象处理订单信息并返回结算结果给用户对象。

交互示例（Interaction Example）：

• 用户（User）对象发送“浏览商品”消息给商品（Product）对象。
• 商品对象返回商品详细信息给用户对象。
• 用户对象发送“添加到购物车”消息给购物车（Shopping Cart）对象，并附带所选商品的信息。
• 购物车对象更新购物车状态，并返回确认消息给用户对象。
• 用户对象发送“提交订单”消息给订单（Order）对象，并附带购物车中的商品信息。
• 订单对象处理订单信息，进行结算，并返回结算结果给用户对象。

在实际的UML建模中，可以使用顺序图（Sequence Diagram）或协作图（Collaboration Diagram）来描述交互的详细过程。顺序图显示了对象之间消息传递的顺序和时间关系，而协作图则强调了对象之间的结构关系和协作方式。这些图表可以帮助我们理解和可视化系统中对象之间的动态行为和交互过程。

UML中的交互描述了系统执行过程中对象之间的通信和协作，包括消息传递、操作调用和状态变化等。通过定义交互，我们可以更好地理解系统的动态行为，并确保系统中的对象能够正确地进行协作和交互，以实现特定的功能和任务。

2.2.2 状态机

在UML中，状态机（State Machine）是一种用于描述对象在其生命周期内状态变化的模型。它描述了对象在不同状态下的行为以及状态之间的转换条件。状态机用于捕捉对象在不同情境下的反应和行为，是建模系统中动态行为的重要工具之一。

状态机的定义通常包括以下几个部分：

• 状态（State）：状态是对象在其生命周期中的某个条件或模式。每个状态都定义了对象在该状态下的行为和属性。
• 转换（Transition）：转换是状态之间的变化过程。它描述了从一个状态到另一个状态的转换条件和触发事件。当满足转换条件时，对象会从当前状态转移到下一个状态。
• 事件（Event）：事件是导致状态转换的触发器。它可以是外部事件（如用户操作）、内部事件（如系统通知）或时间事件（如定时器到期）。
• 动作（Action）：动作是在状态转换过程中执行的行为或活动。它可以是进入或退出状态时的动作，或在特定状态下执行的动作。

例如，考虑一个简单的电梯系统，其中电梯具有不同的状态，如开门、关门、上升和下降等。电梯的状态根据用户按下的按钮和其他条件进行转换。

在这个示例中，电梯的状态机可以描述如下：

• 状态：

  • 开门（Door Open）：电梯门打开，乘客可以进出。
  • 关门（Door Closed）：电梯门关闭，准备移动。
  • 上升（Up）：电梯正在上升。
  • 下降（Down）：电梯正在下降。

• 转换：

  • 当用户按下电梯外部的按钮或电梯内部的楼层按钮时，从“关门”状态转换为“开门”状态。
  • 当电梯门关闭并且选择了一个目标楼层时，从“开门”状态转换为“上升”或“下降”状态。
  • 当电梯到达目标楼层时，从“上升”或“下降”状态转换为“开门”状态。

• 事件：

  • 按钮按下（Button Pressed）：用户按下电梯外部的按钮或电梯内部的楼层按钮。
  • 门关闭（Door Closed）：电梯门完全关闭。
  • 到达楼层（Floor Reached）：电梯到达目标楼层。

• 动作：

  • 打开门：当进入“开门”状态时，执行打开电梯门的动作。
  • 关闭门：当进入“关门”状态时，执行关闭电梯门的动作。
  • 启动移动：当进入“上升”或“下降”状态时，执行启动电梯移动的动作。
  • 停止移动：当进入“开门”状态时，执行停止电梯移动的动作。

在实际的UML建模中，可以使用状态图（State Diagram）来描述状态机的详细模型。状态图显示了对象的不同状态、转换条件、触发事件和动作，帮助我们理解和可视化对象的状态变化和行为。通过定义状态机，我们可以更好地捕捉和理解系统中对象的动态行为，并确保系统在不同状态下能够正确地响应和处理各种事件和条件。

2.2.3 活动

在UML中，活动（Activity）是描述系统或对象执行过程的一种模型元素。活动代表了业务流程、操作流程或系统功能执行的一系列步骤和动作。活动通常用于描述系统中的工作流、任务流或交互流程，并可以包含决策点、并发执行和同步点等元素。

活动的定义通常包括以下几个部分：

• 动作（Action）：动作是活动的基本构成单元，代表了执行过程中的一个步骤或操作。动作可以是原子性的，也可以是由多个子动作组成的复合动作。
• 控制流（Control Flow）：控制流描述了动作之间的执行顺序和条件。它定义了动作之间的转移和决策点，以及可能的分支和合并。
• 对象流（Object Flow）：对象流描述了活动中涉及的对象及其之间的关系。它表示了对象在活动之间的传递、使用和变换。
• 决策点（Decision Node）：决策点是活动中的条件判断点，根据特定条件决定控制流的分支。它允许根据条件选择不同的执行路径。
• 同步点（Synchronization Point）：同步点是活动中的等待或会合点，用于协调并发执行的动作或子活动。它确保相关动作在继续执行之前达到一致状态。

例如，考虑一个简单的在线购物系统中的订单处理流程。该流程包括接收订单、验证订单、处理支付和发货等一系列步骤。

在这个示例中，订单处理流程可以建模为一个活动，具体描述如下：

• 接收订单（Receive Order）：接收客户提交的订单信息。
• 验证订单（Validate Order）：验证订单的完整性和有效性，如检查库存和价格等。
• 处理支付（Process Payment）：处理客户的支付信息，并与支付系统进行交互。
• 发货（Ship Order）：准备商品并安排发货。

这些步骤可以通过一系列动作来表示，并使用控制流来描述它们之间的顺序和条件。例如，如果订单无效，则可以通过一个决策点来中断流程并返回错误信息；如果支付成功，则可以继续到发货步骤；如果支付失败，则可以重新尝试支付或取消订单。

在实际的UML建模中，可以使用活动图（Activity Diagram）来描述活动的详细模型。活动图显示了活动中的动作、控制流、对象流、决策点和同步点等元素，帮助我们理解和可视化系统中的业务流程和执行过程。通过定义活动，我们可以更好地组织和描述系统中的工作流和任务流，以及它们之间的关系和交互。

2.3 分组事物

包

在UML中，包（Package）是一种组织和管理模型元素的方式。它提供了一种将相关元素分组在一起的机制，以形成更高层次的结构和模块化。包可以用于对模型元素进行分类、划分访问权限、实现代码重用和模块化设计。

包的定义通常包括以下几个部分：

• 名称：每个包都有一个唯一的名称，用于标识和引用该包。
• 元素：包可以包含其他包、类、接口、组件、用例、关系等模型元素。这些元素在包内定义，并与包一起构成一个逻辑单元。
• 可见性：包可以设置其内部元素的可见性，以控制其他包或元素对其的访问权限。常见的可见性级别有公有（public）、受保护（protected）和私有（private）。
• 依赖关系：包之间可以存在依赖关系，表示一个包依赖于另一个包中的元素。这种依赖关系可以在不同包之间进行交互和协作时产生影响。

例如，考虑一个图书馆管理系统，其中包括用户管理、图书管理、借阅管理等多个功能模块。为了更好地组织这些功能模块和相关类，我们可以使用包来进行分组。

在这个示例中，我们可以创建以下几个包：

• 用户管理包（User Management Package）：包含与用户相关的类，如用户实体类、用户登录验证类等。
• 图书管理包（Book Management Package）：包含与图书相关的类，如图书实体类、图书目录管理类等。
• 借阅管理包（Borrowing Management Package）：包含与借阅相关的类，如借阅记录类、借阅操作类等。

通过将相关类分组到不同的包中，我们可以实现更好的代码组织和模块化设计。每个包可以独立开发、测试和重用，降低了系统的复杂性。同时，通过使用包的可见性和依赖关系，我们可以控制不同包之间的交互和访问权限，提高了系统的安全性和可维护性。

在实际的UML建模中，可以使用包图（Package Diagram）来描述包的结构和关系。包图显示了包之间的依赖关系和包含关系，帮助我们理解和可视化系统的模块结构和组织方式。通过定义包，我们可以更好地管理和组织UML模型中的元素，提高建模的效率和质量。

2.4 注释事物

注释事物（Commenting Elements）是一种模型元素，用于在模型中提供解释性、描述性或指导性的信息。注释事物不直接影响系统的执行或行为，但可以帮助开发人员、设计师和其他利益相关者更好地理解和解释模型。

注释事物的定义主要包括以下几个方面：

• 文本描述：注释事物通常包含一段文本描述，用于提供对模型中某个元素或情况的说明或解释。这段文本可以是简短的注释、描述性段落或更详细的解释。
• 关联对象：注释事物可以与模型中的其他元素关联，如类、接口、用例、活动等。通过关联对象，注释事物可以针对特定的模型元素提供附加信息或解释。
• 可视化表示：在UML图中，注释事物通常表示为带有注释符号（如注释框或云朵形状）的图形元素。注释符号中包含注释文本，有时还可以包含其他格式化信息（如标记、颜色等）。

示例：

考虑一个简单的在线商店系统，其中包含一个名为“购物车”的类。为了更好地解释购物车类的功能和用途，我们可以使用注释事物来提供额外的信息。

在这个示例中，我们可以创建一个注释事物，具体描述如下：

• 文本描述：“购物车类用于存储用户选择的商品，并提供计算总价和结算的功能。”
• 关联对象：将注释事物与“购物车”类关联起来，表明这段注释是对该类的描述。
• 可视化表示：在UML类图中，我们可以使用带有注释符号的图形元素来表示这个注释事物。注释符号可以放置在“购物车”类附近，并用箭头指向该类，以显示它们之间的关联。

在实际的UML建模中，注释事物可以帮助提高模型的可读性和可理解性。通过在模型中添加解释性和描述性的信息，注释事物可以促进团队成员之间的沟通和协作，并确保对模型的一致理解。此外，注释事物还可以用于记录设计决策、系统约束或其他重要信息，以便在开发过程中进行参考和回顾。

三、关系

3.1 依赖关系

依赖关系（Dependency）是一种描述模型元素之间关系的方式，表示一个元素依赖于另一个元素的存在或行为。依赖关系表明一个元素在某种程度上依赖于另一个元素，当被依赖的元素发生变化时，可能会影响依赖它的元素。

依赖关系的定义通常包括以下几个方面：

• 方向性：依赖关系具有方向性，表示依赖的方向。通常使用一个带箭头的线来表示依赖关系，箭头指向被依赖的元素。
• 临时性：依赖关系通常是临时的，只在特定的上下文或场景中存在。一旦上下文改变，依赖关系可能也随之改变或消失。
• 可见性：依赖关系可以具有不同的可见性级别，如公有（public）、私有（private）等。可见性级别决定了其他元素如何访问和使用依赖关系。

示例：

考虑一个简单的在线商店系统，其中包括一个“用户”类和一个“订单”类。在这个系统中，“订单”类依赖于“用户”类，因为每个订单必须与一个用户相关联。

在这个示例中，我们可以描述以下依赖关系：

• “订单”类依赖于“用户”类：每个订单必须有一个与之相关联的用户。这种依赖关系可以通过在“订单”类中添加一个属性（如“用户”）来表示，该属性是对“用户”类的一个引用。
• 创建订单时依赖于用户信息：在创建订单的过程中，需要获取用户的信息（如姓名、地址等）。这意味着“订单”类的某些方法（如创建订单的方法）可能会调用“用户”类的某些方法来获取必要的信息。这种依赖关系可以通过在UML类图中使用带箭头的虚线来表示，箭头从“订单”类指向“用户”类，表示调用关系。

在实际的UML建模中，依赖关系可以用不同的方式表示，如在类图中使用带箭头的线、在序列图中使用消息流等。此外，还可以使用一些特定的UML构造型（Stereotype）来进一步描述依赖关系的性质，如<>表示一个元素使用另一个元素的服务或功能。

理解和管理依赖关系对于软件系统的设计和维护至关重要。通过对依赖关系进行建模和分析，开发人员可以更好地了解系统组件之间的相互作用和影响，从而作出合理的设计决策和优化系统的结构。同时，减少不必要的依赖关系和降低耦合度也是提高软件质量和可维护性的关键措施之一。

3.2 关联关系

关联关系（Association）是一种描述模型元素之间结构关系的方式，表示两个或多个类之间存在某种联系或连接。关联关系描述了类之间的静态结构，即对象之间的连接方式和它们如何相互引用。

关联关系的定义通常包括以下几个方面：

1. 结构性：关联关系是类之间的一种结构性关系，描述了类之间的静态连接。它表示了类之间的对象如何在运行时相互引用和连接。
2. 导航性：关联关系可以具有导航性，即从一个类的对象可以访问到另一个类的对象。这通过关联关系上的箭头来表示，箭头指向可导航的方向。
3. 多重性：关联关系可以具有多重性，描述了关联两端类的对象之间的数量关系。常见的多重性包括一对一（1:1）、一对多（1:N）、多对一（N:1）和多对多（N:M）等。

示例：

考虑一个简单的在线商店系统，其中包括“顾客”（Customer）类和“商品”（Product）类。在这个系统中，顾客可以购买多个商品，每个商品也可以被多个顾客购买。因此，“顾客”类和“商品”类之间存在一个多对多的关联关系。

具体地，这个关联关系可以描述如下：

1. “顾客”类和“商品”类之间存在关联关系：每个顾客可以购买多个商品，每个商品也可以被多个顾客购买。这表示“顾客”类和“商品”类之间有一种连接或联系。
2. 关联关系具有导航性：从“顾客”类的对象可以访问到其购买的“商品”类的对象列表，反之亦然。这可以通过在关联关系上添加箭头来表示，箭头指向可导航的方向。
3. 关联关系具有多重性：由于一个顾客可以购买多个商品，而一个商品也可以被多个顾客购买，所以这是一个多对多的关联关系。在UML类图中，可以使用多重性标记（如“*”表示多个）来表示这种数量关系。

在实际的UML建模中，关联关系通常用一条实线来表示，可以在关联线上添加箭头表示导航性，还可以在关联线的两端添加多重性标记来表示数量关系。此外，还可以使用一些特定的UML构造型（Stereotype）来进一步描述关联关系的性质，如<>表示一个类的对象拥有另一个类的对象。

通过建模关联关系，开发人员可以更好地理解类之间的联系和相互作用，从而设计出更合理和灵活的系统结构。同时，关联关系也为实现类之间的交互和协作提供了基础，帮助开发人员更好地组织和管理代码。

3.3 泛化关系

在UML（Unified Modeling Language，统一建模语言）中，泛化关系（Generalization）是一种描述类之间继承关系的方式，表示一个类（子类）继承另一个类（父类）的属性和方法。泛化关系也称为“继承关系”，是面向对象编程中一种重要的关系。

泛化关系的定义包括以下几个方面：

1. 继承性：泛化关系表示子类继承了父类的属性和方法。子类可以重用父类的代码，并在需要时添加或覆盖父类的行为。
2. 传递性：泛化关系具有传递性，即如果类B继承自类A，类C继承自类B，那么类C也间接继承自类A。这意味着子类可以继承父类以及父类的父类的属性和方法。
3. 多态性：泛化关系支持多态性，即子类可以以父类的形式出现。这意味着可以使用父类的引用来引用子类的对象，并在运行时根据实际对象的类型调用相应的方法。

示例：

考虑一个简单的动物分类系统，其中包括一个“动物”（Animal）类和一个“狗”（Dog）类。在这个系统中，“狗”类是“动物”类的子类，继承了“动物”类的属性和方法。

具体地，这个泛化关系可以描述如下：

1. “动物”类是父类，“狗”类是子类：“狗”类继承了“动物”类的属性和方法，如“吠叫”（bark）、“奔跑”（run）等。这表示“狗”类是“动物”类的一个特殊化或具体化。
2. 泛化关系具有传递性：如果有一个“牧羊犬”（ShepherdDog）类作为“狗”类的子类，那么“牧羊犬”类也间接继承自“动物”类。这意味着“牧羊犬”类可以继承“动物”类和“狗”类的属性和方法。
3. 泛化关系支持多态性：可以使用“动物”类的引用来引用“狗”类或“牧羊犬”类的对象，并在运行时根据实际对象的类型调用相应的方法。例如，可以定义一个名为“动物叫声”（animalSound）的方法，在“动物”类中定义为虚方法（virtual method），在“狗”类中覆盖（override）为“汪汪叫”（woof），在“牧羊犬”类中覆盖为特定的叫声。这样，当通过“动物”类的引用调用“animalSound”方法时，会根据实际对象的类型（狗或牧羊犬）播放相应的叫声。

在实际的UML建模中，泛化关系通常用一条带空心的三角箭头的实线来表示，箭头指向父类。这个空心三角箭头是泛化关系的标志性符号，用于区分其他类型的关系。此外，还可以在泛化关系线上添加一些标签或注释来提供额外的信息，如访问修饰符（public、protected、private）或约束条件等。

通过建模泛化关系，开发人员可以更好地组织和管理代码，实现代码的重用和扩展。泛化关系也为构建更复杂的系统提供了基础，通过将公共的行为和属性抽象到父类中，可以简化子类的设计和实现，并提高系统的可维护性和可扩展性。

3.4 实现关系

实现关系（Realization）是一种描述类（或组件）与其接口之间关系的方式，表示类实现了某个接口所定义的行为。实现关系在面向对象编程中非常重要，它确保类遵循接口规定的契约，从而实现代码的解耦和灵活性。

实现关系的定义包括以下几个方面：

1. 契约性：接口定义了一组方法的契约，即方法名称、参数和返回类型。实现关系表示类实现了接口所规定的这些方法，从而满足了接口的契约。
2. 多重性：一个类可以实现多个接口，这意味着它可以同时遵循多个接口定义的契约。这有助于实现代码的灵活性和可扩展性。
3. 多态性：实现关系支持多态性，即一个接口可以有多个实现类。这意味着可以使用接口引用来引用实现类的对象，并在运行时根据实际对象的类型调用相应的方法。

示例：

考虑一个简单的在线支付系统，其中包括一个“支付方式”（PaymentMethod）接口和一个“信用卡支付”（CreditCardPayment）类。在这个系统中，“信用卡支付”类实现了“支付方式”接口，从而提供了一种具体的支付方式。

具体地，这个实现关系可以描述如下：

1. “支付方式”接口定义了一个“支付”（pay）方法，该方法接受支付金额作为参数。这表示任何实现“支付方式”接口的类都需要提供“支付”方法的具体实现。
2. “信用卡支付”类实现了“支付方式”接口：这意味着“信用卡支付”类必须提供“支付”方法的具体实现。在实现过程中，“信用卡支付”类可能需要调用银行API或其他支付网关来完成实际的支付操作。
3. 实现关系支持多态性：可以使用“支付方式”接口的引用来引用“信用卡支付”类的对象，并在运行时调用其“支付”方法。例如，可以定义一个名为“处理支付”（processPayment）的方法，该方法接受一个“支付方式”接口的引用作为参数，并在内部调用该引用的“支付”方法。这样，当传入不同的实现类对象（如“信用卡支付”类或其他实现类的对象）时，该方法可以根据实际对象的类型调用相应的支付方法。

在实际的UML建模中，实现关系通常用一条带空心的三角箭头的虚线来表示，箭头指向接口。这个空心三角箭头是实现关系的标志性符号，用于区分其他类型的关系。此外，还可以在实现关系线上添加一些标签或注释来提供额外的信息，如接口名称或方法签名等。

通过建模实现关系，开发人员可以更好地理解类与接口之间的关系，并确保类实现了接口所规定的行为。这有助于实现代码的解耦和可扩展性，同时提高了系统的灵活性和可维护性。

四、公共机制

（暂略，待举例说明）