UML图例详解

志向和热爱是伟大行为的双翼。

UML(Unified Modeling Language)是一种统一建模语言,为面向对象开发系统的产品进行说明、可视化、和编制文档的一种标准语言。
在这里将介绍 UML 基本概念以及各个图的使用场景。


UML 图例详解

UML 分为用例视图、设计视图、进程视图、实现视图和拓扑视图,又可以静动分为静态视图和动态视图。静态图分为:用例图,类图,对象图,包图,构件图,部署图。动态图分为:状态图,活动图,协作图,序列图。

用例图(UseCase Diagrams)

用例是目标系统业务过程(Business Process)的抽象,由参与者(Actor)与系统的交互步骤(或事件)组成,参与者通过用例完成具体的业务目标。
即:用例图主要回答了两个问题:
1. 是谁用软件
2. 软件的功能
从用户的角度描述了系统的功能,并指出各个功能的执行者,强调用户的使用者,系统为执行者完成哪些功能。

系统用例模型通过 UML 用例图进行可视化。UML 用例图基本符号有 用例(椭圆形标识)、参与者(人性标识)、系统边界(矩形标识)、关联(直线标识)

  • 如图 1.1 所示:

    UML用例图
    图1.1    UML用例图基本符号

用例建模 是面向对象软件分析的重要技术和方法,开发人员在实用用例图进行用例模型可视化时需要注意如下事项

  1. 用例图无法可视化非交互或非功能性的系统需求;
  2. 用例的定义没有统一标准;
  3. 复杂系统用例模型的全局可视化可能会降低用例图的可用性等。

序列图-时序图(Sequence Diagrams)

UML时序图通过对象、消息、交互顺序等方式可视化软件业务过程中的控制流或数据流。

时序图中的对象通过发送消息和接受消息进行交互,消息具有先后顺序。UML时序图基本符号有对象、消息、对象生命线、消息组合片段、终止符号等

  • 时序图如图 1.2 所示:

    UML时序图
    图1.2    UML时序图基本符号

消息用从一个对象的生命线到另一个对象生命线的箭头表示。

箭头以时间顺序在图中从上到下排列。

生命线

生命线名称可带下划线。当使用下划线时,意味着序列图中的生命线代表一个类的特定实例。

  • 生命线如图 1.3 所示:

    生命线
    图1.3    生命线

同步消息

同步等待消息。

  • 同步消息如图 1.4 所示:

    同步消息
    图1.4    同步消息

异步消息

异步发送消息,不需等待。

  • 异步消息如图 1.5 所示:

    异步消息
    图1.5    异步消息

注释

  • 注释如图 1.6 所示:

    注释
    图1.6    注释

约束

  • 约束如图 1.7 所示:

    约束
    图1.7    约束

组合

组合片段用来解决交互执行的条件及方式。
它允许在序列图中直接表示逻辑组件,用于通过指定条件或子进程的应用区域,为任何生命线的任何部分定义特殊条件和子进程。
常用的组合片段有:抉择、选项、循环、并行

使用时序图 进行对象交互模型可视化时,需要注意如下事项

  1. 消息类型有同步消息、异步消息、返回消息、自关联消息等;
  2. 如果需要在时序图中标注对象生命周期的终止,可以使用终止符号;
  3. 可以对时序图标注对象类型(Type)构造类型(Stereotype)
  4. 当系统内部对象需要和系统外部环境交互时,可以将外部环境(第三方系统或用户)标注为对象。

类图(Class Diagrams)

类是面向对象软件分析和设计的核心目标。
定义了静态代码逻辑,是软件内部的泛化(Generalization)类型;对象是类的实例;类的关联是对象写作逻辑的静态表示。
采用面向对象方法实施软件编码活动的本质是定义类。

用户根据用例图抽象成类,描述类的内部结构和类与类之间的关系,是一种静态结构图。
在UML类图中,常见的有以下几种关系:

类图不仅可以用于呈现需求的业务领域,也可以用于表达逻辑代码的设计模型。

各种关系的强弱顺序: 泛化(继承) = 实现 > 组合 > 聚合 > 关联 > 依赖

泛化(继承)

【泛化关系】:是一种继承关系,表示一般与特殊的关系,它指定了子类如何继承父类的所有特征和行为。

例如:学生(Student) 也同样是 人(Person),即有学生的特性也有人类的共性。

泛化
泛化(继承)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 定义 Person 类
class Person {
private String name;
private int age;

public Person(String name, int age) {
this.name = name;
this.age = age;
}

@Override
public String toString() {
return "{Name: " + this.name + ", Age: " + this.age + "}\n";
}
}

// 定义 Student 类,继承 Person 类
class Student extends Person {
private String studentID;

public Student(String name, int age, String studentID) {
super(name, age);
this.studentID = studentID;
}

@Override
public String toString() {
return super.toString() + "{Student ID: " + this.studentID + "}";
}
}

实现

【实现关系】:是一种类与接口的关系,表示类是接口所有特征和行为的实现。

泛化
实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 定义动作接口 Action
interface Action {
void Running();
void Sleeping();
}

// 定义 Animals 类,实现动作接口 Action
class Animals implements Action {
@Override
public void Running() {
System.out.println("It's Running!");
}

@Override
public void Sleeping() {
System.out.println("It's Sleeping!");
}
}

关联

【关联关系】:是一种拥有的关系,它使一个类知道另一个类的属性和方法;
如:老师与学生,丈夫与妻子关联可以是双向的,也可以是单向的。
双向的关联可以有两个箭头或者没有箭头,单向的关联有一个箭头。

【代码体现】:成员变量

关联
关联

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 定义学院类 College
class College {
private String name;
private ArrayList<Student> student; // 学生与学院 n : 1

public Courses(String name) {
this.name = name;
this.student = new ArrayList<>();
}

// 省略 getter 和 setter 方法...
}

// 定义学生类 Students
class Student {
private ArrayList<Teacher> teachers; // 学生与老师 n : m

public Student() {
this.teachers = new ArrayList<>();
}

// 省略 getter 和 setter 方法...
}

// 定义教师类 Teacher
class Teacher {
private ArrayList<Student> students; // 学生与老师 n : m

public Teacher() {
this.students = new ArrayList<>();
}

// 省略 getter 和 setter 方法...
}

聚合

【聚合关系】:是整体与部分的关系,且部分可以离开整体而单独存在。如车和轮胎是整体和部分的关系,轮胎离开车仍然可以存在。

聚合关系是关联关系的一种,是强的关联关系; 关联和聚合在语法上无法区分,必须考察具体的逻辑关系。

【代码体现】:成员变量

聚合
聚合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// 定义引擎类 Engine
class Engine {
private String name;

public Engine(String name) {
this.name = name;
}

public String getName() {
return name;
}
}

// 定义汽车类 Car
class Car {
private Engine engine; // 1:1 聚合关系
private Tyre[] tyres = new Tyre[4]; // 1:4 聚合关系

public Car() {
engine = new Engine("Engine");
}

public Engine getEngine() {
return engine;
}

public Tyre[] getTyres() {
return tyres;
}
}

// 定义轮胎类 Tyre
class Tyre {
public void running() {
System.out.println("Tyre is running...");
}
}

组合

【组合关系】:是整体与部分的关系,但部分不能离开整体而单独存在。如公司和部门是整体和部分的关系,没有公司就不存在部门。

组合关系是关联关系的一种,是比聚合关系还要强的关系,它要求普通的聚合关系中代表整体的对象负责代表部分的对象的生命周期。

【代码体现】:成员变量

【箭头及指向】:带实心菱形的实线,菱形指向整体

组合
组合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 定义公司类 Company
class Company {
private String name;

public Company(String name) {
this.name = name;
}
}

// 定义部门类 Department
class Department {
private Company company;

public Department(Company company) {
this.company = company;
}
}

依赖

【依赖关系】:是一种使用的关系,即一个类的实现需要另一个类的协助,所以要尽量不使用双向的互相依赖.

【代码表现】:局部变量、方法的参数或者对静态方法的调用

【箭头及指向】:带箭头的虚线,指向被使用者

依赖
依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 定义计算机类 Computer
class Computer {
private String name;
private static String cpu = "Intel";

public Computer(String name) {
this.name = name;
}

public String getName() {
return name;
}

public static String showCPU() {
return cpu;
}
}

// 定义人类 People
class People {
// 使用局部方法参数
public void getComputerName(Computer computer) {
System.out.println(computer.getName());
}

// 使用静态方法
public void getComputerCPU() {
System.out.println(Computer.showCPU());
}
}

类图应用

类图应用
类图应用

使用类图 进行建模时,需要注意如下事项

  1. 类图可以呈现域、方法和类关系等代码要素,但无法表达详细业务流程。因此,如果只有类图模型,则并不能直接进行程序实现;
  2. 类图文档通常与代码实现不一致,且更新代价较高;
  3. 从静态代码形式上看,不同的类关系代码形式常常相同或类似。因此,一般按系统对象的角色或业务职责区分类关系。
-------------本文结束 Euphoria 在此感谢您的阅读-------------

本文标题:UML图例详解

文章作者:王钦弘

发布时间:2019年08月28日 - 16:13

最后更新:2020年01月15日 - 04:30

原始链接:https://www.wqh4u.cn/2019/08/28/UML%E5%9B%BE%E4%BE%8B%E8%AF%A6%E8%A7%A3/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

您的支持将鼓励 Euphoria 继续创作!
(如果你还是学生请千万不要打赏!留点钱在学习上啊!)