作为一名高级开发者需要具备的技能之画UML类图

心已赠人 2022-10-12 04:22 154阅读 0赞

>  写在前面：大家好！我是`AC-fun`,我的昵称来自两个单词`Accepted`和`fun`。我是一个热爱ACM的蒟蒻。如果博客中有不足或者的错误的地方欢迎在评论区或者私信我指正，感谢大家的不吝赐教。我的唯一博客更新地址是：[https://ac-fun.blog.csdn.net/][https_ac-fun.blog.csdn.net]。非常感谢大家的支持。一起加油，冲鸭！  
>  `用知识改变命运，用知识成就未来！加油 (ง •̀o•́)ง (ง •̀o•́)ง`

### 文章目录 ###

*  简介
 *  类与类之间的关系
 *   *  继承关系
     *  实现关系
     *  关联关系
     *  聚合关系
     *  组合关系
     *  依赖关系
 *  总结

# 简介 #

在之前的博客：**[如何使用IDEA画UML图][IDEA_UML]** 中已经详细的说明了如何使用 **IDEA** 画 **UML图**。本篇博客来详细的讲解一下 **UML** 的类图怎样画。在 **UML** 的 **13** 种图中，`类图` 是使用频率最高的 **UML** 图之一。作为一名开发人员画类图是必须具备的技能。类图可以帮助我们简洁明了的描述系统中的类，以及各个类之间的关系的静态视图，能够更好的帮助我们在开发系统之前对系统有一个全面的认识。

类图也可以更好的帮助其他开发者快速的了解我们的系统。类图是一种静态模型类型。类图表示类、接口和它们之间的协作关系，用于 **系统设计阶段**。

类图用 **3** 个矩形拼接表示，最上面的部分标识类的名称，如果是接口则需要在类名上方添加 `<<Interface>>`，中间标识类的属性，最下面标识类的方法。如下图所示： 
![类图简介][20210703164510562.png] 
生成该图的 **UML** 语言代码如下：

@startuml
 
 class Person {
 + name : String
 - age : int
 # weight : double
 ~ height : double
 + sex : char
 
 + eat(food)
 # drink()
 - walk()
 ~ run()
 + study()
 + {static}playGames()
 }
 
 note left of Person : + 表示 public\n - 表示 private\n # 表示 protected\n ~ 表示 default，可省略不写
 note right of Person : 字段和方法返回值的类型非必须，可以不写。\n静态类或者静态方法在下方画横线，\n在PlantUML中在静态方法或属性前面加{static}，抽象加{abstract}
 
 right footer https://ac-fun.blog.csdn.net/
 @enduml

# 类与类之间的关系 #

类与类之间的关系一共有 **6** 种，分别是：**继承（泛化）关系、实现关系、组合关系、聚合关系、关联关系和依赖关系**。下面分别来详解一下如何只用 **PlantUML** 画这 **6** 种关系。

## 继承关系 ##

继承关系又叫做泛化关系，在此关系中子类继承父类的所有功能，也就是说父类有的属性、方法，子类都会具有。除了从父类继承来的功能，子类还可以继续扩展父类的功能，从而具有父类所不具有的功能。比如一个师傅带一个徒弟练武，徒弟继承了师傅的所有武功，后来徒弟又自创了武功，这就是继承关系。

结合代码来说，例如，汽车的种类有很多种，有公交车、出租车等等。它们都有自己的特点，但是它们又有很多共同点。这里的汽车就可以作为父类，而公交车和出租车则是汽车的子类。其代码和类图如下：

public class Car { 
        private String name;
        public void run(){ }
    }
    
    public class Bus extends Car { 
    
    }
    
    public class Taxi extends Car { 
    
    }

![Car类图][Car]  
生成该图的 **UML** 语言代码如下：

@startuml
 
 class Car {
 - name : String
 + run()
 }
 
 class Bus
 
 class Taxi
 
 Car <|-- Bus
 Car <|-- Taxi
 
 right footer https://ac-fun.blog.csdn.net/
 @enduml

注：类之间的继承（泛化）关系通过 `<|--` 或者 `--|>`来表示，其中箭头指向父类，表示箭尾的类继承了箭头的类。

## 实现关系 ##

实现关系实际上就是 **A** 类实现了 **B** 类，在实现关系中，类实现了接口，类中的方法实现了接口中的所有方法。例如：或火车和飞机都是交通工具，而交通工具只是一个抽象的概念，它们的运行方式不同，都通过不同的方式具体实现了移动的功能。其代码以及类图如下：

package com.acfun.practice;
    
    public interface Vehicle { 
        void run();
    }

package com.acfun.practice;
    
    /** * @description: 火车类 * @author: ACfun * @create: 2021-07-03 18:00 **/
    public class Train implements Vehicle{ 
        @Override
        public void run() { 
            System.out.println("火车在地上跑...");
        }
    }

package com.acfun.practice;
    
    /** * @description: 飞机类 * @author: ACfun * @create: 2021-07-03 18:01 **/
    public class Plane implements Vehicle{ 
        @Override
        public void run() { 
            System.out.println("飞机在天上飞...");
        }
    }

![Vehicle类图][Vehicle]  
生成该图的 **UML** 语言代码如下：

@startuml
 
 interface Vehicle {
 + {static}run()
 }
 
 class Plant {
 - name : String
 + run()
 }
 
 class Train {
 - name : String
 + run()
 }
 
 Vehicle <|.. Train
 Vehicle <|.. Plant
 
 right footer https://ac-fun.blog.csdn.net/
 @enduml

注：类之间的实现关系通过 `..|>` 或者 `<|..` 表示，箭头指向的为接口，箭尾为实现接口的类。注意顺序不要反了。

## 关联关系 ##

关联关系是类与类之间最常见的一种关系，表示一类对象与另一类对象之间有联系。后面的聚合、组合也属于关联关系，它们之间的区别在于关联关系的类之间的关系比聚合、组合关系都要弱。组合关系最强。

关联关系有四种：双向关联、单向关联、自关联、多重性关联。例如汽车和司机，一辆汽车对应特定的司机，一个司机对应特定的汽车。其代码和类图如下：

package com.acfun.practice.Association;
    
    /** * @description: 司机类 * @author: ACfun * @create: 2021-07-03 19:31 **/
    public class Driver { 
        private Car car;
        
        public void addCar(Car car) { 
            this.car = car;
        }
    }

package com.acfun.practice.Association;
    
    /** * @description: 汽车类 * @author: ACfun * @create: 2021-07-03 19:30 **/
    public class Car { 
        private Driver driver;
        public void addDriver(Driver driver) { 
            this.driver = driver;
        }
    }

![关联关系][20210703193922186.png]  
生成该图的 **UML** 语言代码如下：

@startuml
 
 class Driver {
 - car : Car
 + addCar()
 }
 
 class Car {
 - driver : Driver
 + addDriver()
 }
 
 Driver "1"--"1" Car
 
 right footer https://ac-fun.blog.csdn.net/
 
 @enduml

## 聚合关系 ##

聚合关系表示整体与部分之间的关系，整体与部分可以进行分离，部分对象可以脱离整体对象独立存在。比如台式电脑的主机和屏幕、鼠标的关系。屏幕和鼠标可以放在别的主机使用，主机也可以更换别的屏幕、鼠标。其代码和类图如下：

package com.acfun.practice.computer;
    
    /** * @description: 鼠标类 * @author: ACfun * @create: 2021-07-03 18:54 **/
    public class Mouse { 
    }

package com.acfun.practice.computer;
    
    /** * @description: 屏幕类 * @author: ACfun * @create: 2021-07-03 18:55 **/
    public class Screen { 
    }

package com.acfun.practice.computer;
    
    /** * @description: 电脑类 * @author: ACfun * @create: 2021-07-03 18:55 **/
    public class Computer { 
        private Mouse mouse; // 鼠标可以和主机分离
        private Screen screen; // 屏幕可以和主机分离
    
        public void setMouse(Mouse mouse) { 
            this.mouse = mouse;
        }
    
        public void setScreen(Screen screen) { 
            this.screen = screen;
        }
    }

![Computer类图][Computer]  
生成该图的 **UML** 语言代码如下：

@startuml
 
 class Computer {
 - mouse : Mouse
 - screen : Screen
 
 + setMouse()
 + setScreen()
 }
 
 class Mouse
 class Screen
 
 Computer o-- Mouse
 Computer o-- Screen
 
 right footer https://ac-fun.blog.csdn.net/
 
 @enduml

注：类之间的聚合关系通过 `o--` 或者 `--o` 表示，箭头指向的为整体，箭尾为部分。

## 组合关系 ##

组合关系表示类之间整体与部分的关系，这里要重点强调的是这个整体与部分有一直的生存周期，共同存亡。一旦整体对象不在，部分对象也将不会存在。例如，人由头和身体组成，两者不可分割，共同存在。其代码和类图如下：

package com.acfun.practice.Person;
    
    /** * @description: 头部类 * @author: ACfun * @create: 2021-07-03 19:42 **/
    public class Head { 
        private String name;
    }

package com.acfun.practice.Person;
    
    /** * @description: 身体类 * @author: ACfun * @create: 2021-07-03 19:43 **/
    public class Body { 
        private String name;
    }

package com.acfun.practice.Person;
    
    /** * @description: 人类 * @author: ACfun * @create: 2021-07-03 19:42 **/
    public class Human { 
        private Head head;
        private Body body;
    }

![组合关系][20210703194852531.png]  
生成该图的 **UML** 语言代码如下：

@startuml
 
 class Head {
 - name : String
 }
 
 class Body {
 - name : String
 }
 
 class Human {
 - head : Head
 - body : Body
 }
 
 Human *-- Head
 Human *-- Body
 
 right footer https://ac-fun.blog.csdn.net/
 @enduml

## 依赖关系 ##

依赖关系是一种“使用”关系，只要是在类中用到了对方，那么它们之间就有依赖关系。比如说 **A类** 用到了 **B类**，那么就说 **A类** 依赖于 **B类**。如果没有 **B类**，那么将会编译不通过。使用依赖关系在大多数情况下，依赖关系体现在某个类的方法是用另一个类的对象作为参数。例如，汽车依赖汽油，如果没有汽油，那么汽车将无法行驶。该例子的代码和类图如下：

package com.acfun.practice.CarOil;
    
    /** * @description: 汽油类 * @author: ACfun * @create: 2021-07-06 17:56 **/
    public class Oil { 
        private String type;
    }

package com.acfun.practice.CarOil;
    
    /** * @description: 汽车类 * @author: ACfun * @create: 2021-07-06 18:00 **/
    public class Car { 
        public void run(Oil oil) { 
    
        }
    }

![依赖关系示例][20210706180632946.png]  
生成该图的 **UML** 语言代码如下：

@startuml
 
 class Car {
 + run(Oil oil)
 }
 
 class Oil {
 - type : String
 }
 
 Car ..> Oil
 
 right footer https://ac-fun.blog.csdn.net/
 
 @enduml

注：

# 总结 #

从以上讲解我们可以看出：继承关系、实现关系和关联关系是依赖关系的特例，组合关系和聚合关系是关联关系的特例。所以归根到底它们都是一种关系，那就是依赖关系。只是根据情况的不同将它们具体分成了不同的关系。我们可以从强弱角度来进行理解，各类关系从强到弱依次是：继承关系 > 实现关系 > 组合关系 > 聚合关系 > 关联关系 > 依赖关系。

--------------------

> 未完待续，持续更新中……  
> ![57ea24a902c0ef59039b4c7cc9c94ad4.gif][]

[https_ac-fun.blog.csdn.net]: https://ac-fun.blog.csdn.net/
[IDEA_UML]: https://ac-fun.blog.csdn.net/article/details/117908372
[20210703164510562.png]: /images/20221005/35c2e963b9134a518d0b6097f79faaa6.png
[Car]: /images/20221005/ba7cd016be6941d6a602b72c9d235a1b.png
[Vehicle]: /images/20221005/20d38d57e5554ee7980e34dcd976fbde.png
[20210703193922186.png]: /images/20221005/376ea8eddd8343f8bd08b071f9ff8d01.png
[Computer]: /images/20221005/2ccedbf7687646e7ad7d96df14db2a61.png
[20210703194852531.png]: /images/20221005/bb5a46b4fafd4d9cbe7b354515d18131.png
[20210706180632946.png]: /images/20221005/11f9d23f03eb46a49beddeafb15c1e7b.png
[57ea24a902c0ef59039b4c7cc9c94ad4.gif]: /images/20221005/1c2d0260b56b45118521c5d5cc927a72.png