【Java基础】UML类图及各种线代表的关系含义总结

￡神魔★判官ぃ 2022-10-20 00:53 333阅读 0赞

### 文章目录 ###

*   *  一.UML常见图
     *   *  1.类图(Class Diagram)
         *  2.对象图(Object Diagram)
         *  3.时序图(Sequence Diagram)
     *  二.UML类图线的概括
     *   *  1.类（Class）
         *  2.接口（interface）
         *  3.泛化(generalization)—继承关系
         *  4.实现(realization)—接口实现关系
         *  5.依赖(dependency)—使用关系
         *  6.关联(association)— 拥有关系
         *  7.组合和聚合概念简单理解
         *  8.聚合(aggregation)—组合类需要被组合类存在才能构建，被组合类可以单独存在
         *  9.组合(composition)— 组合类需要被组合类存在才能构建，被组合类不可以单独存在
         *  10.各类关系强弱
     *  三.生活案例之动物衍生关系图
     *  四.关联关系、聚合关系、组合关系之间的区别
     *  五.类关系记忆技巧

## 一.UML常见图 ##

### 1.类图(Class Diagram) ###

类图是显示一组类、接口、协作以及它们之间关系的图。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 1]

### 2.对象图(Object Diagram) ###

对象图是表示在某一时间点上一组对象以及它们之间的关系的图。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 2]

### 3.时序图(Sequence Diagram) ###

时序图显示对象之间的关系，强调对象之间消息的时间顺序，显示对象之间的交互。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 3]

## 二.UML类图线的概括 ##

<table> 
 <thead> 
  <tr> 
   <th>关系</th> 
   <th>线</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>继承</td> 
   <td><img src="https://img-blog.csdnimg.cn/2021071214415551.png" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td>实现</td> 
   <td><img src="https://img-blog.csdnimg.cn/20210712144208756.png" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td>依赖</td> 
   <td><img src="https://img-blog.csdnimg.cn/20210712144229824.png" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td>关联</td> 
   <td><img src="https://img-blog.csdnimg.cn/20210712144245678.png" alt="在这里插入图片描述"> ，注意:<code>双向关联可以有两个箭头或者没有箭头，单向的关联有一个箭头</code></td> 
  </tr> 
  <tr> 
   <td>组合</td> 
   <td><img src="https://img-blog.csdnimg.cn/20210712143221122.png" alt="在这里插入图片描述"> <br><img src="https://img-blog.csdnimg.cn/20210712144343437.png" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>聚合</td> 
   <td><img src="https://img-blog.csdnimg.cn/20210712143212355.png" alt="在这里插入图片描述"> <br> <img src="https://img-blog.csdnimg.cn/20210712144408206.png" alt="在这里插入图片描述"></td> 
  </tr> 
 </tbody> 
</table>

### 1.类（Class） ###

**使用`3层矩形框`表示**

*  第1层显示`类的名称`，如果是抽象类，则就用`斜体`显示。
 *  第2层是`字段和属性`。
 *  第3层是`类的方法`。 注意前面的符号，`+表示public`，`-表示private`，`#表示protected`

![在这里插入图片描述][20210712135531975.png_pic_center]

### 2.接口（interface） ###

**使用`2层矩形框`表示，与类图的区别主要是顶端有`<<interface>>`显示**

*  第一层是`接口名称`
 *  第二层是`接口方法`。  
    ![在这里插入图片描述][20210712140942721.png_pic_center]

### 3.泛化(generalization)—继承关系 ###

*  **继承类（extends） ：用`实线空心箭头`来表示**。**在Java中，用`extends`关键字来继承一个类**
    
     *  继承关系中，子类会继承所具有的属性、方法，子类应该都有。子类还可以有自己独有的属性、方法。
    
    > 在UML中 继承抽象类，无论类名还是抽象方法名，都以斜体的方式表示，因为这也是一种继承关系，所以子类与父类通`实线空心箭头`来联系。
    
     *  例如出租车、公交车、货车都是属于车，它们都有自己的名字，都可以上路跑。

**java代码**

class Car{ 
    	//汽车名字
    	private String name;
    	public String getName(){ this.name;};
    	public String setName(String name){ this.name= name;};
    	//跑
    	public String run(){ this.name;};
    }
     //公交车
    class Bus extends Car{ }
    
     //出租车
    class Taxi extends Car{ }

**类图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 4]

> 注意：`箭头方向是子类指向父类。`
> 
>  *  泛化是依赖关系的特例

### 4.实现(realization)—接口实现关系 ###

*  **实现接口（implements） ：用`虚线空心箭头`来表示** **在Java中，用`implements`关键字来实现一个接口。**
 *  接口（包括抽象类）是方法的集合，实现接口的具体实现类需要实现接口下的所有方法。
    
     *  汽车和轮船都是交通工具，而交通工具只是一个可移动工具的抽象概念，船和车实现了具体移动的功能。

java代码：

//交通工具
    interface Vehicle{ 
    	//移动
        public void run();
    }
    
     //汽车
    class Car implements Vehicle{ 
    	//汽车的名称(独有属性)
    	private String name;
        @Override
        public void run() { 
        }
    }
    
    //轮船
    class Ship implements Vehicle{ 
    	//轮船的名称(独有属性)
    	private String name;
        @Override
        public void run() { 
        }
    }

类图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 5]

> 实现是依赖关系的特例

### 5.依赖(dependency)—使用关系 ###

*  **依赖（Dependency） ：用`虚线箭头`来表示 是一种`使用的关系`，即一个类的实现需要另一个类的协助。`在Java中，方法参数需要传入另一个类的对象，就表示依赖这个类`。**
    
     *  大多数情况下，依赖关系体现`在某个类的方法使用另一个类的对象作为参数`。
    
    > 只要是在类中用到了对方，那么他们之间就存在依赖(Dependency)关系。如果没有对方，连编绎都通过不了的那种。比如
    > 
    >  *  类中用到了对方
    >  *  是类的成员属性
    >  *  是方法的返回类型
    >  *  是方法接收的参数类型
    >  *  方法中使用到
 *  例如：汽车依赖汽油，如果没有汽油，汽车将无法行驶。

java代码

//汽车
    class Car{ 
        public void beforeRun(Oil oil){ 
            System.out.println("使用"+oil.getType+"号企业");
        }
    }
     
    //汽油
    class Oil { 
    	//汽油类型
    	private String type;
    	private String getType(){ this.type;};
    	private String setType(String type){ this.type = type;};
    }

类图  
![在这里插入图片描述][20210712144920957.png]

> 注意：类A需要用到类B，类A指向类B。

### 6.关联(association)— 拥有关系 ###

*  **关联（Association） ：用`实线箭头`来表示** **在Java中，`一个类的全局变量引用了另一个类，就表示关联了这个类`**

>  *  关联关系是类与类之间最常用的一种关系，表示一类对象与另一类对象之间有联系。`组合、聚合也属于关联关系`，`只是关联关系的类间关系比其他两种要弱`。
>  *  关联关系有4种：`双向关联、单向关联、自关联、多重数关联。`
>  *  在多重性关系中，可以直接在关联直线上增加一个`数字`，`表示与之对应的另一个类的对象的个数。`
>     
>      *  1…1：仅一个
>      *  0…\*：零个或多个
>      *  1…\*：一个或多个
>      *  0…1：没有或只有一个
>      *  m…n：最少m、最多n 个(m<=n)依赖关系

*  例如：汽车和司机，一辆汽车对应特定的司机，一个司机也可以开多辆车。(这按一个司机固定开司机专属的车来设计)

**java代码**  
单向关联

//学生
    class Student{ 
    	private Pen pen;
    }
    //笔
    class Pen{ 
    }

双向关联

//司机
    class Driver{ 
        private  Car[] cars;;
        public void  addCar(Car car){ 
            this.cars.add(car);
        }
    }
    //车 
    class Car{  
        private  Driver[] drivers;
        public void  addDriver(Driver driver){ 
            this.drivers.add(driver);
        }
    }

类图  
![在这里插入图片描述][20210712150713423.png]

> 注意：类A中用到类B属性，类A指向类B。
> 
>  *  关联是依赖关系的特例

### 7.组合和聚合概念简单理解 ###

*  **聚合**：就是说各个对象聚合在一起工作，但是我没有你也行，我照样可以正常运行。
 *  **组合**呢，关系就比较密切，组合中的各个对象之间组成了一个整体，缺少了某一个对象就不能正常运行或者说功能会有很大缺陷。
 *  也就是说`聚合对象 "不具备相同生命周期"，而组合对象 "具有相同的生命周期"`

**举个例子：**

*  比如：**`电脑和U盘`就是 “聚合”，而`电脑显示器和主机`就是 “组合”**。

### 8.聚合(aggregation)—组合类需要被组合类存在才能构建，被组合类可以单独存在 ###

*  **聚合（Aggregation） ：用`尾部为空心菱形的实线箭头（也可以没箭头）`来表示：是一种`弱的‘拥有’`关系，体现的是`A对象可以包含B对象，但B对象不是A对象的一部分`**
    
     *  **`在聚合关系中，成员对象是整体的一部分，但是成员对象可以脱离整体对象独立存在。`Java代码实现聚合关系，成员对象通常`以构造方法、Setter方法的方式注入到整体对象之中`。**
     *  例如：公交车司机和工衣、工帽是整体与部分的关系，但是可以分开，工衣、工帽可以穿在别的司机身上，公交司机也可以穿别的工衣、工帽。

//公交车司机
    class BusDriver{ 
        private Clothes clothes;
        private  Hat hat;
        public void setClothes(Clothes clothes){ this.clothes= clothes;}
        public void setHat(Hat hat){ this.hat= hat;}
        public void show(){ 
                System.out.println("我穿了"+clothes.getName()+"的工衣,戴了"+hat.getName()+"的工帽");
    	}
    }
    	
    //工衣
    class Clothes{ 
    	//工衣类型
    	private String name;
    	public String getName(){ this.name;};
    	public String setName(String name){ this.name= name;};
    }
    //工帽
    class Hat{ 
    	//工衣类型
    	private String name;
    	public  String getName(){ this.name;};
    	public String setName(String name){ this.name= name;};;
    }

类图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 6]

> 注意：类A中用到类B属性，类A指向类B。

*  这六种类关系中，`组合、聚合和关联的代码结构一样`，可以从关系的强弱来理解。
 *  聚合属于关联的特例

### 9.组合(composition)— 组合类需要被组合类存在才能构建，被组合类不可以单独存在 ###

*  **组合（Composition）：用`尾部为实心菱形的实线箭头（也可以没箭头）`来表示。**
    
     *  组合关系也表示的是一种`整体和部分`的关系，但是在组合关系中`整体对象可以控制成员对象的生命周期，一旦整体对象不存在，成员对象也不存在，整体对象和成员对象之间具有同生共死的关系`
     *  **Java代码实现组合关系，通常 `在整体类的构造方法中直接实例化成员类`**，这是因为组合关系的整体和部分是共生关系，如果通过外部注入，那么即使整体不存在，那么部分还是存在的，这就相当于变成了一种聚合关系了。
     *  例如：人由头部和身体组成，两者不可分割，共同存在。通常是在构造函数的时候，通过new创建出来。

**java代码**

//人
    class Human{ 
        private Head head;
        private  Body body;
        public void setHead(Head head){ this.head = head;}
        public void setBody(Body body){ this.body = body;}
    }
    //头
    class Head{ }
    //身体
    class Body { }

**类图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 7]

> 注意：类A中用到类B属性，类A指向类B。

*  这六种类关系中，`组合、聚合和关联的代码结构一样`，可以从关系的强弱来理解。
 *  组合属于关联的特例

### 10.各类关系强弱 ###

**各类关系从强到弱依次是：`继承→实现→组合→聚合→关联→依赖`。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 8]

## 三.生活案例之动物衍生关系图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 9]

## 四.关联关系、聚合关系、组合关系之间的区别 ##

从上文可以看出，关联关系、聚合关系和组合关系三者之间比较相似，本文的最后就来总结一下这三者之间的区别。

**关联和聚合的区别主要在于语义上**

*  `关联的两个对象之间一般是平等的，聚合则一般是不平等的`。

**聚合和组合的区别则在语义和实现上都有差别：**

*  `组合`的两个对象之间生命周期有很大的关联，被组合的对象在组合对象创建的同时或者创建之后创建，在组合对象销毁之前销毁，一般来说被组合对象不能脱离组合对象独立存在，而且也只能属于一个组合对象；
 *  `聚合`则不一样，被聚合的对象可以属于多个聚合对象。

**再举例子来说：**

*  你和你的朋友属于`关联关系`，因为你和你的朋友之间的关系是平等的，关联关系只是表示一下两个对象之间的一种简单的联系而已，就像我有一个朋友
 *  你和你借的书属于`聚合关系`，第一是因为书可以独立存在，第二是因为书不仅仅属于你，也可以属于别人，只是暂时你拥有
 *  你和你的心脏属于`组合关系`，因为你的心脏只是属于你的，不能脱离与你而存在

## 五.类关系记忆技巧 ##

**继承实现，箭头方向：从子类指向父类。**

1.  定义子类是需要通过`extends`关键字指定父类；
2.  子类一定是知道父类定义的，但父类并不知道子类的定义；
3.  只有知道对方信息时才能指向对方；
4.  所以箭头的方向是从子类指向父类。

**继承实现：用线条连接两个类。**

1.  空心三角箭头表示继承或实现
2.  实线表示继承，是is-a 的关系，表示扩展，不虚，很结实；
3.  虚线表示实现，虚线代表“虚”无实体。

**关联依赖：用线条连接两个类。**

1.  虚线表示依赖关系：  
    临时用一下，若即若离，虚无缥缈，若有若无；表示一种使用关系，一个类需要借助另一类来实现功能；一般是一个类将另一个类作为参数使用，或作为返回值。
2.  实线表示关联关系：  
    关系稳定，实打实的关系，铁哥们；表示一个类对象和另一个类对象有关联；通常是一个类中有另一个类对象作为属性。

**组合聚合：用菱形表示。**

1.  菱形就是像是一个盛东西的器皿（比如盘子）；
2.  聚合：空心菱形，代表空器皿里可以放很多相同的东西，聚集在一起（箭头方向所指的类）；整体和局部的关系，两者有独立的生命周期，是has-a 的关系；弱关系，消极的词：弱-空。
3.  组合：实心菱形，代表器皿里已经有实体结构的存在，生死与共；整体与局部的关系，和聚合关系对比，关系更加强烈；两者具有相同的生命周期，contains-a 的关系；强关系，积极的词：强-满。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]: /images/20221004/61bccda9dbb644dca7b3eb0071988047.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 1]: /images/20221004/d3bbf9b617914a739fa814ba2a364035.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 2]: /images/20221004/edd7b576ecb943b6a058597c1e192753.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 3]: /images/20221004/811d81813ee140f79f90401df25ebcbe.png
[20210712135531975.png_pic_center]: /images/20221004/4fb1e167ecbd429394b7c28ad1eecc94.png
[20210712140942721.png_pic_center]: /images/20221004/a85d806e01fb4c12a1fb73bba32602b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 4]: /images/20221004/86ce8d25aac34f8bade00b2d3fff6fd5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 5]: /images/20221004/3e3152168ee0480d9d4fdc556f623720.png
[20210712144920957.png]: /images/20221004/3caf4fb095f5429d811c16ecf8bd1677.png
[20210712150713423.png]: /images/20221004/9609999857314870ab6f4d99b366a788.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 6]: /images/20221004/998358d277de4501bd8853e3c1f4de0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 7]: /images/20221004/b3e90aaa83714753b2a501aaa8ba4e3d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 8]: /images/20221004/55418165f613424e997bd8343c3a0235.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 9]: /images/20221004/efbd305079084b088d323b5f83f2e769.png