一、基本元素：类、接口、枚举的 UML 表示

1. 类（Class）

UML 中类用矩形框表示，分为 3 层：

• 第 1 层：类名（首字母大写）
• 第 2 层：属性（成员变量）
• 第 3 层：方法（成员方法）

访问修饰符符号：

• +：public（公共）
• -：private（私有）
• #：protected（受保护）
• ~：package-private（默认，无修饰符）

public class User {
    private Long id;       // 私有属性
    private String username;// 公有属性
    public String currentDate;//公有属性
    public User() {}       // 构造方法
    public String getUsername() { // 私有方法
        return username;
    }
    public String getCurrentDate() { // 私有方法
        return currentDate;
    }
    private void change(){}
}

2. 接口（Interface）

UML 中接口用矩形框表示，顶部标注 <<interface>>，包含公共抽象方法（Java 8+ 允许默认方法和静态方法）

public interface IUserService {
    void save(User user);  // 抽象方法（默认public abstract）
    default void update() {  // 默认方法（Java 8+）
        // 实现
    }
    static void delete() {  // 静态方法（Java 8+）
        // 实现
    }
}

抽象方法（Abstract Method）只能包含方法的 “声明部分”，不能包含任何实现代码。不能用 private（抽象方法需要被子类 / 实现类重写，private 会限制访问）。

接口：只能定义 公共静态常量（默认 public static final，必须初始化，且无法修改），有构造方法（用于子类初始化时调用），但抽象类本身不能实例化。

        Java 8 前：只能包含 抽象方法（默认 public abstract，无方法体）。
        Java 8 后：可包含 默认方法（default 修饰，有方法体）和 静态方法（static 修饰）。
        Java 9 后：可包含 私有方法（private 修饰，仅接口内部复用）。

抽象类：包含任意类型的属性（public/private/protected、静态 / 非静态、可变 / 不可变），没有构造方法（接口不能被实例化，也无需初始化属性，因为属性都是静态常量）。

         抽象方法（abstract 修饰，无方法体）和 非抽象方法（有方法体）。

区别点	抽象类（Abstract Class）	接口（Interface）
继承方式	单继承（extends）	多实现（implements）
方法类型	抽象方法 + 非抽象方法	抽象方法 + 默认方法（Java 8+） + 静态方法（Java 8+）
属性类型	任意属性（可私有、可变）	仅公共静态常量（public static final）
构造方法	有（供子类调用）	无
核心目的	提供公共实现，定义 “是什么”	定义行为规范，定义 “能做什么”

3. 枚举（Enum）

UML 中枚举用矩形框表示，顶部标注 <<enumeration>>，包含枚举常量和方法。

public enum Status {
    //枚举常量
    ACTIVE(1, "活跃"),
    INACTIVE(0, "禁用");
    //私有属性
    private int code;
    private String desc;
    //方法
    Status(int code, String desc) {
        this.code = code;
        this.desc = desc;
    }
    
    public int getCode() {
        return code;
    }
}

枚举（Enumeration，简称 Enum） 是一种特殊的类，用于定义固定数量的常量集合（如季节、星期、状态等）。

enum Season {
    SPRING,  // 枚举常量（每个常量都是Season的实例）
    SUMMER,
    AUTUMN,
    WINTER   // 最后一个常量可省略逗号
}

枚举的核心特性

1. 不可实例化：枚举类不能通过 new 关键字创建实例（构造方法默认为 private，且无法修改为 public）。
2. 不可继承：枚举类默认继承 java.lang.Enum 类，而 Java 不支持多继承，因此枚举类不能被其他类继承。
3. 常量唯一性：枚举中的每个常量都是唯一的实例，可通过名称直接访问（如 Season.SPRING）。

枚举不仅可以定义常量，还可以包含属性、构造方法和普通方法，甚至抽象方法，使其具备更灵活的功能。枚举常量必须在最前面声明，且需传入构造方法参数。

带属性和构造方法的枚举

enum Weekday {
    MONDAY("周一", 1),
    TUESDAY("周二", 2),
    WEDNESDAY("周三", 3),
    THURSDAY("周四", 4),
    FRIDAY("周五", 5),
    SATURDAY("周六", 6),
    SUNDAY("周日", 7);
    // 枚举的属性（通常为私有，通过getter访问）
    private final String chineseName;
    private final int index;
    // 构造方法（必须是private，默认也是private）
    private Weekday(String chineseName, int index) {
        this.chineseName = chineseName;
        this.index = index;
    }
    // 普通方法（提供属性访问）
    public String getChineseName() {
        return chineseName;
    }
    public int getIndex() {
        return index;
    }
}

// 获取MONDAY的中文名称和索引
String mondayName = Weekday.MONDAY.getChineseName(); // 结果："周一"
int mondayIndex = Weekday.MONDAY.getIndex(); // 结果：1

带抽象方法的枚举

enum Operation {
    ADD {
        public int calculate(int a, int b) {
            return a + b;
        }
    },
    SUBTRACT {
        public int calculate(int a, int b) {
            return a - b;
        }
    },
    MULTIPLY {
        public int calculate(int a, int b) {
            return a * b;
        }
    };    // 抽象方法（每个枚举常量必须实现）
    public abstract int calculate(int a, int b);
}

int a = 10;
int b = 5;
// 调用ADD的calculate()：执行加法
int sum = Operation.ADD.calculate(a, b);
System.out.println(a + " + " + b + " = " + sum); // 输出：10 + 5 = 15

方法	说明	示例
values()	返回包含所有枚举常量的数组（顺序与声明一致）	Season[] seasons = Season.values();
valueOf(String name)	根据名称获取枚举常量（名称必须完全匹配，否则抛异常）	Season spring = Season.valueOf("SPRING");
ordinal()	返回常量的索引（从 0 开始，与声明顺序相关）	int index = Season.SPRING.ordinal(); // 0
name()	返回常量的名称（字符串形式）	String name = Season.SUMMER.name(); // "SUMMER"

二、常见关系的 UML 表示

1. 继承（泛化，Generalization）

• 含义：类与类之间的继承（extends），或接口与接口之间的继承。
• UML 符号：带空心三角形的实线（三角形指向父类 / 父接口）。

//类继承类
public class UserServiceImpl extends ServiceImpl<UserMapper, User> {
    // 实现
}

2. 实现（Realization）

• 含义：类实现接口（implements）。
• UML 符号：带空心三角形的虚线（三角形指向接口）。

//类实现接口
public class UserServiceImpl implements IUserService {
    // 实现
}

3. 关联（Association）

• 含义：类与类之间的 “拥有” 关系（如双向引用）。
• UML 符号：实线（可带箭头表示方向，无箭头表示双向）。

public class Order {
    private User user;  // 关联User
}
public class User {
    private List<Order> orders;
}

4. 依赖（Dependency）

• 含义：类 A 使用类 B（如方法参数、局部变量），但不 “拥有” B。
• UML 符号：带箭头的虚线（箭头指向被依赖的类）。

//UserService 依赖 UserMapper
public class UserService {
    public void save(User user) {
        UserMapper mapper = new UserMapper();  // 局部变量依赖
        mapper.insert(user);
    }
}

5. 聚合（Aggregation）与组合（Composition）

• 聚合：“整体 - 部分” 关系，部分可独立于整体存在（如 “班级 - 学生”）。
  UML 符号：带空心菱形的实线（菱形在整体端）。

• 组合：“整体 - 部分” 关系，部分不可独立于整体存在（如 “人与心脏”）。
  UML 符号：带实心菱形的实线（菱形在整体端）。