Skip to content
Java陈序员Java陈序员
首页
开源项目open in new window
github icon
  • 设计模式
    • 设计模式七大原则
      • UML 类图
        • 1. UML基本介绍
          • 1.2 UML图
            • 1.3 UML类图
              • 1.4 类图—依赖关系(DEPENDENCE)
                • 1.5 类图—泛化关系(GENERALIZATION)
                  • 1.6 类图—实现关系(IMPLEMENTATION)
                    • 1.7 类图—关联关系(ASSOCIATION)
                      • 1.8 类图—聚合关系(AGGREGATION)
                        • 1.8.1 基本介绍
                          • 1.8.2 应用实例
                          • 1.9 类图—组合关系(COMPOSITION)
                            • 1.9.1 基本介绍
                              • 1.9.2 应用案例
                            • 单例模式
                              • 工厂模式
                                • 原型模式
                                  • 建造者模式
                                    • 适配器模式
                                      • 桥接模式
                                        • 装饰者模式
                                          • 组合模式
                                            • 外观模式
                                              • 享元模式
                                                • 代理模式
                                                  • 模板方法模式
                                                    • 命令模式
                                                      • 访问者模式
                                                        • 迭代器模式
                                                          • 观察者模式
                                                            • 中介者模式
                                                              • 备忘录模式
                                                                • 解释器模式
                                                                  • 状态模式
                                                                    • 策略模式
                                                                      • 责任链模式

                                                                        UML 类图

                                                                        author iconJava陈序员原创💡calendar icon2022年6月2日category icon
                                                                        • 设计模式
                                                                        tag icon
                                                                        • UML
                                                                        timer icon大约 4 分钟

                                                                        此页内容
                                                                        • 1. UML基本介绍
                                                                        • 1.2 UML图
                                                                        • 1.3 UML类图
                                                                        • 1.4 类图—依赖关系(DEPENDENCE)
                                                                        • 1.5 类图—泛化关系(GENERALIZATION)
                                                                        • 1.6 类图—实现关系(IMPLEMENTATION)
                                                                        • 1.7 类图—关联关系(ASSOCIATION)
                                                                        • 1.8 类图—聚合关系(AGGREGATION)
                                                                          • 1.8.1 基本介绍
                                                                          • 1.8.2 应用实例
                                                                        • 1.9 类图—组合关系(COMPOSITION)
                                                                          • 1.9.1 基本介绍
                                                                          • 1.9.2 应用案例

                                                                        # UML 类图

                                                                        # 1. UML基本介绍

                                                                        1. UML——Unified Modeling Language(统一建模语言),是一种用于软件系统分析和设计的语言工具,它用于帮助软件开发人员进行思考和记录思路的结果。
                                                                        2. UML 本身是一套符号的规定,就像数学符号和化学符号一样,这些符号用于描述软件模型中的各个元素和他们之间的关系,比如类、接口、实现、泛化、依赖、组合、聚合等。
                                                                        3. 使用 UML 来建模,常用的工具有 RationalRose, 也可以使用一些插件来建模。
                                                                        4. 在 IDEA 中可安装插件 PlantUML Integration

                                                                        # 1.2 UML图

                                                                        画 UML 图与写文章差不多,都是把自己的思想描述给别人看,关键在于思路和条理,UML 图分类:

                                                                        • 用例图(usecase)
                                                                        • 静态结构图:类图、对象图、包图、组件图、部署图
                                                                        • 动态行为图:交互图(时序图与协作图)、状态图、活动图

                                                                        说明:类图是描述类与类之间的关系的,是 UML 图中最核心的。

                                                                        # 1.3 UML类图

                                                                        1. 用于描述系统中的类 ( 对象 ) 本身的组成和类 ( 对象 ) 之间的各种静态关系。

                                                                        2. 类之间的关系:依赖、泛化(继承)、实现、关联、聚合、组合。

                                                                        3. 类图简单举例

                                                                           public class Person {
                                                                          
                                                                              public Integer id;
                                                                          
                                                                              public String name;
                                                                          
                                                                              public String getName() {
                                                                                  return name;
                                                                              }
                                                                          
                                                                              public void setName(String name) {
                                                                                  this.name = name;
                                                                              }
                                                                          }
                                                                          
                                                                          1
                                                                          2
                                                                          3
                                                                          4
                                                                          5
                                                                          6
                                                                          7
                                                                          8
                                                                          9
                                                                          10
                                                                          11
                                                                          12
                                                                          13
                                                                          14

                                                                          对应的类图:

                                                                          image-20220602094046233

                                                                        # 1.4 类图—依赖关系(DEPENDENCE)

                                                                        只要是在类中用到了对方,那么他们之间就存在依赖关系。如果没有对方,连编绎都通过不了。

                                                                        public class PersonService {
                                                                        
                                                                            private PersonDao personDao;
                                                                        
                                                                            public void save(Person person) {}
                                                                        
                                                                            public IDCard getIDCard() {
                                                                                return null;
                                                                            }
                                                                        
                                                                            public void modify() {
                                                                                Department department = new Department();
                                                                            }
                                                                        }
                                                                        
                                                                        class Person {}
                                                                        
                                                                        class Department {}
                                                                        
                                                                        class IDCard {}
                                                                        
                                                                        class PersonDao {}
                                                                        
                                                                        1
                                                                        2
                                                                        3
                                                                        4
                                                                        5
                                                                        6
                                                                        7
                                                                        8
                                                                        9
                                                                        10
                                                                        11
                                                                        12
                                                                        13
                                                                        14
                                                                        15
                                                                        16
                                                                        17
                                                                        18
                                                                        19
                                                                        20
                                                                        21
                                                                        22

                                                                        对应的类图:

                                                                        image-20220602095516518

                                                                        小结:

                                                                        1. 类中用到了对方
                                                                        2. 是类的成员属性
                                                                        3. 是方法的返回类型
                                                                        4. 是方法接收的参数类型
                                                                        5. 方法中使用到

                                                                        # 1.5 类图—泛化关系(GENERALIZATION)

                                                                        泛化关系实际上就是继承关系,是依赖关系的特例。

                                                                        public class DaoSupport {
                                                                        
                                                                            public void save(Object entity) {
                                                                        
                                                                            }
                                                                        
                                                                            public void delete(Object id) {
                                                                                
                                                                            }
                                                                        }
                                                                        
                                                                        class PersonDao extends DaoSupport {
                                                                            
                                                                        }
                                                                        
                                                                        1
                                                                        2
                                                                        3
                                                                        4
                                                                        5
                                                                        6
                                                                        7
                                                                        8
                                                                        9
                                                                        10
                                                                        11
                                                                        12
                                                                        13
                                                                        14

                                                                        对应的类图:

                                                                        image-20220602100334272

                                                                        小结:

                                                                        1. 泛化关系实际上就是继承关系
                                                                        2. 如果 A类 继承了 B类,我们就说 A 和 B 存在泛化关系

                                                                        # 1.6 类图—实现关系(IMPLEMENTATION)

                                                                        实现关系实际上就是 A类 实现 B 接口,他是依赖关系的特例。

                                                                        public interface PersonService {
                                                                        
                                                                            public void delete(Integer id);
                                                                        }
                                                                        
                                                                        1
                                                                        2
                                                                        3
                                                                        4
                                                                        public class PersonServiceImpl implements PersonService {
                                                                        
                                                                            @Override
                                                                            public void delete(Integer id) {
                                                                        
                                                                            }
                                                                        }
                                                                        
                                                                        1
                                                                        2
                                                                        3
                                                                        4
                                                                        5
                                                                        6
                                                                        7

                                                                        对应的类图:

                                                                        image-20220602101503384

                                                                        # 1.7 类图—关联关系(ASSOCIATION)

                                                                        关联关系实际上就是类与类之间的联系,是依赖关系的特例。

                                                                        关联关系具有导航性:即双向关系或者单向关系。

                                                                        关联关系具有多重性:如 “1” 表示有且仅有一个,“0...” 表示0个或者多个,“0,1” 表示0个或者一个,“n...m” 表示 n 到 m 个都可以,“m...*”表示至少m个。

                                                                        单向一对一关系

                                                                        public class Person {
                                                                        	private IDCard card;
                                                                        }
                                                                        
                                                                        1
                                                                        2
                                                                        3

                                                                        双向一对一关系

                                                                        public class Person {
                                                                        	private IDCard card;
                                                                        }
                                                                        
                                                                        public class IDCard{
                                                                        	private Person person
                                                                        }
                                                                        
                                                                        1
                                                                        2
                                                                        3
                                                                        4
                                                                        5
                                                                        6
                                                                        7

                                                                        # 1.8 类图—聚合关系(AGGREGATION)

                                                                        # 1.8.1 基本介绍

                                                                        聚合关系(Aggregation)表示的是整体和部分的关系,整体与部分可以分开。聚合关系是关联关系的特例,所以他具有关联的导航性与多重性。 如:一台电脑由键盘(keyboard)、显示器(monitor),鼠标等组成;组成电脑的各个配件是可以从电脑上分离出来的,使用带空心菱形的实线来表示。

                                                                        # 1.8.2 应用实例

                                                                        public class Computer {
                                                                            private Mouse mouse;
                                                                            
                                                                            private Monitor monitor;
                                                                        
                                                                            public void setMouse(Mouse mouse) {
                                                                                this.mouse = mouse;
                                                                            }
                                                                        
                                                                            public void setMonitor(Monitor monitor) {
                                                                                this.monitor = monitor;
                                                                            }
                                                                        }
                                                                        
                                                                        class Mouse {}
                                                                        
                                                                        class Monitor {}
                                                                        
                                                                        1
                                                                        2
                                                                        3
                                                                        4
                                                                        5
                                                                        6
                                                                        7
                                                                        8
                                                                        9
                                                                        10
                                                                        11
                                                                        12
                                                                        13
                                                                        14
                                                                        15
                                                                        16
                                                                        17

                                                                        对应的类图:

                                                                        image-20220602103454763

                                                                        # 1.9 类图—组合关系(COMPOSITION)

                                                                        # 1.9.1 基本介绍

                                                                        组合关系:也是整体与部分的关系,但是整体与部分不可以分开。

                                                                        案例:在程序中我们定义实体:Person 与 IDCard、Head, 那么 Head 和 Person 就是 组合,IDCard 和 Person 就是聚合。

                                                                        但是如果在程序中 Person 实体中定义了对 IDCard 进行级联删除,即删除 Person 时连同 IDCard 一起删除,那么 IDCard 和 Person 就是组合了。

                                                                        # 1.9.2 应用案例

                                                                        public class Person {
                                                                            
                                                                            private IDCard idCard;
                                                                            
                                                                            private Header header = new Header();
                                                                        }
                                                                        
                                                                        class IDCard {}
                                                                        
                                                                        class Header {}
                                                                        
                                                                        1
                                                                        2
                                                                        3
                                                                        4
                                                                        5
                                                                        6
                                                                        7
                                                                        8
                                                                        9
                                                                        10

                                                                        对应的类图:

                                                                        image-20220602104109938

                                                                        案例 2

                                                                        public class Computer {
                                                                            private Mouse mouse = new Mouse();
                                                                        
                                                                            private Monitor monitor = new Monitor();
                                                                            
                                                                        }
                                                                        
                                                                        class Mouse {}
                                                                        
                                                                        class Monitor {}
                                                                        
                                                                        1
                                                                        2
                                                                        3
                                                                        4
                                                                        5
                                                                        6
                                                                        7
                                                                        8
                                                                        9
                                                                        10

                                                                        对应的类图:

                                                                        image-20220602104419018

                                                                        edit icon编辑此页open in new window
                                                                        上次编辑于: 2022/6/2 下午3:25:25
                                                                        贡献者: cyl
                                                                        上一页
                                                                        设计模式七大原则
                                                                        下一页
                                                                        单例模式
                                                                        没有最好,只有更好!
                                                                        Copyright © 2024 Java陈序员