PlantUML类图：用代码思维讲清楚UML六大关系（含Java语法对照与记忆口诀）

PlantUML类图：用代码思维讲清楚UML六大关系（含Java语法对照与记忆口诀）

当你第一次接触UML类图时，那些空心菱形、实心箭头是否让你感到困惑？作为开发者，我们每天都在与类和对象打交道，但如何清晰地表达它们之间的关系却是一门学问。本文将带你从Java开发者的视角，用代码思维彻底理解UML六大关系，并附上形象记忆口诀，让你从此不再混淆。

1. 从Java角度看UML基础元素

在深入关系之前，我们需要先了解UML类图的基本构件如何对应到Java代码。一个典型的类图包含以下元素：

class Customer { -name: String +getName(): String #validate(): boolean {static} MAX_AGE: int }

对应的Java代码是：

public class Customer { private String name; public static final int MAX_AGE = 100; public String getName() { return name; } protected boolean validate() { /*...*/ } }

关键对应关系：

• 类名：直接对应Java类声明
• 属性：对应成员变量，可见性符号一致
  • -private
  • #protected
  • ~package-private
  • +public
• 方法：对应类方法，包括参数和返回类型
• 静态成员：用{static}标记

提示：PlantUML默认会将这些可见性符号转换为图形化图标，如需显示原始符号，可添加skinparam classAttributeIconSize 0

2. UML六大关系深度解析

2.1 泛化关系（Generalization）

Java对应：extends关键字
记忆口诀："父子继承空心箭，就像类扩展父链"

class Animal class Dog Dog --|> Animal

对应的Java代码：

class Animal {} class Dog extends Animal {}

关键特点：

• 表示"is-a"关系
• 箭头指向父类
• 继承属性和方法

2.2 实现关系（Realization）

Java对应：implements关键字
记忆口诀："虚线实现三角箭，接口约定必须现"

interface Flyable class Bird Bird ..|> Flyable

Java实现：

interface Flyable { void fly(); } class Bird implements Flyable { public void fly() { /*...*/ } }

对比表格：

2.3 依赖关系（Dependency）

Java表现：方法参数、局部变量、静态调用
记忆口诀："虚线箭头临时用，方法结束关系空"

class Chef class Recipe Chef ..> Recipe

代码表现：

class Chef { void cook(Recipe recipe) { // 参数形式 Recipe temp = recipe; // 局部变量 Recipe.staticMethod(); // 静态调用 } }

2.4 关联关系（Association）

Java表现：成员变量
记忆口诀："实线箭头表拥有，长期存在双向通"

class Teacher class Student Teacher --> Student Student --> Teacher

Java实现：

class Teacher { private List<Student> students; } class Student { private Teacher advisor; }

关联强度比较：

1. 依赖：临时性（方法内部）
2. 关联：持久性（成员变量）
3. 聚合/组合：更强的关联

2.5 聚合关系（Aggregation）

Java表现：可分离的成员变量
记忆口诀："空心菱形整体控，部门员工可调动"

class Department class Employee Department o--> Employee

代码示例：

class Department { private List<Employee> staff; // 员工可以离职 }

2.6 组合关系（Composition）

Java表现：不可分离的成员变量
记忆口诀："实心菱形生命同，人体四肢不离宗"

class Human class Heart Human *--> Heart

Java实现：

class Human { private Heart heart; // 心脏不能独立存在 Human() { heart = new Heart(); // 通常由整体创建部分 } }

3. 六大关系对比与记忆技巧

3.1 关系强度排序

从弱到强排列：

1. 依赖（临时使用）
2. 关联（长期拥有）
3. 聚合（可分离的拥有）
4. 组合（不可分离的拥有）
5. 实现（接口契约）
6. 泛化（父子继承）

3.2 图形特征速记表

3.3 常见误区分辨

问题1：聚合 vs 组合如何判断？

• 关键看生命周期是否独立
• 聚合：部分可以独立存在（如员工离职）
• 组合：部分不能独立存在（如订单项）

问题2：关联 vs 依赖如何选择？

• 关联：作为成员变量存在
• 依赖：仅在方法内部使用

4. 综合应用实例分析

让我们通过一个电商系统案例，综合运用各种关系：

class User { +userId: String +placeOrder() } class Order { -orderId: String -calculateTotal() } class OrderItem { -quantity: int -getSubtotal() } class Product { -productId: String -price: double } interface Payment { +processPayment() } class CreditCardPayment { -cardNumber: String +processPayment() } User --> Order Order *--> OrderItem OrderItem --> Product Order ..> Payment CreditCardPayment ..|> Payment

对应关系解析：

1. User → Order：关联（用户拥有订单）
2. Order → OrderItem：组合（订单项不能独立存在）
3. OrderItem → Product：关联（引用商品信息）
4. Order ‥> Payment：依赖（下单时临时使用支付接口）
5. CreditCardPayment → Payment：实现（具体支付方式）

Java代码骨架：

// 接口定义 interface Payment { boolean processPayment(double amount); } // 实现类 class CreditCardPayment implements Payment { private String cardNumber; public boolean processPayment(double amount) { // 信用卡支付逻辑 } } // 订单相关 class Order { private List<OrderItem> items; // 组合关系 public void addItem(Product p, int qty) { items.add(new OrderItem(p, qty)); } } class OrderItem { private Product product; // 关联 private int quantity; public OrderItem(Product p, int qty) { this.product = p; this.quantity = qty; } }

在实际项目中，明确这些关系可以帮助我们：

• 设计更合理的类结构
• 避免循环依赖
• 明确对象生命周期管理
• 提高代码可读性和可维护性