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

晴空๓

已于 2022-11-07 18:42:30 修改

阅读量906

点赞数 4

分类专栏： Java 文章标签：软件开发类图面向对象设计 UML类图

于 2021-07-06 18:33:20 首次发布

本文链接：https://blog.csdn.net/qq_41575507/article/details/118441319

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

写在前面：大家好！我是晴空๓。如果博客中有不足或者的错误的地方欢迎在评论区或者私信我指正，感谢大家的不吝赐教。我的唯一博客更新地址是：https://ac-fun.blog.csdn.net/。非常感谢大家的支持。一起加油，冲鸭！
用知识改变命运，用知识成就未来！加油 (ง •̀o•́)ง (ง •̀o•́)ง

简介

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

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

类图用 3 个矩形拼接表示，最上面的部分标识类的名称，如果是接口则需要在类名上方添加 <<Interface>>，中间标识类的属性，最下面标识类的方法。如下图所示：
类图简介
生成该图的 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 <font color=red>https://ac-fun.blog.csdn.net/</font>
@enduml

类与类之间的关系

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

继承关系

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

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

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

public class Bus extends Car {

}

public class Taxi extends Car {

}

Car类图
生成该图的 UML 语言代码如下：

@startuml

class Car {
    - name : String
    + run()
}

class Bus

class Taxi

Car <|-- Bus
Car <|-- Taxi

right footer <font color=red>https://ac-fun.blog.csdn.net/</font>
@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类图
生成该图的 UML 语言代码如下：

@startuml

interface Vehicle {
    + {static}run()
}

class Plant {
    - name : String
    + run()
}

class Train {
    - name : String
    + run()
}

Vehicle <|.. Train
Vehicle <|.. Plant

right footer <font color=red>https://ac-fun.blog.csdn.net/</font>
@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;
    }
}

关联关系
生成该图的 UML 语言代码如下：

@startuml

class Driver {
    - car : Car
    + addCar()
}

class Car {
    - driver : Driver
    + addDriver()
}

Driver "1"--"1" Car

right footer <font color=red>https://ac-fun.blog.csdn.net/</font>

@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类图
生成该图的 UML 语言代码如下：

@startuml

class Computer {
    - mouse : Mouse
    - screen : Screen

    + setMouse()
    + setScreen()
}

class Mouse
class Screen

Computer o-- Mouse
Computer o-- Screen

right footer <font color=red>https://ac-fun.blog.csdn.net/</font>

@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;
}

组合关系
生成该图的 UML 语言代码如下：

@startuml

class Head {
    - name : String
}

class Body {
    - name : String
}

class Human {
    - head : Head
    - body : Body
}

Human *-- Head
Human *-- Body

right footer <font color=red>https://ac-fun.blog.csdn.net/</font>
@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) {

    }
}

依赖关系示例
生成该图的 UML 语言代码如下：

@startuml

class Car {
    + run(Oil oil)
}

class Oil {
    - type : String
}

Car ..> Oil

right footer <font color=red>https://ac-fun.blog.csdn.net/</font>

@enduml

注：

总结

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

未完待续，持续更新中……

晴空๓

关注

4
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
6
评论
作为一名高级开发者需要具备的技能之画UML类图

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

扫一扫