UML 类图

概述及作用

这里只是简单的概括一下，具体完整的定义可以自行查询相关资料。文章只给出 IDEA 自动生成的 UML 类图，关于软件工程标准的类图暂时没有（作者太懒了。

在软件工程中，类图是一种静态的结构图，描述了系统的类的集合，类的属性（成员变量、方法）和类之间的关系。它是系统分析和设计阶段产生的，用来简化了人们对系统的理解。

类图表示法

类（接口）的表示

包含三部分：类名（接口名）、成员变量、方法。

这是一个学生类：

class Student {
    private String name;
    
    private Integer age;
    
    public void study(String course) {
        log.info("study{}...", course);
    }
}

IDEA 生成的 UML 类图表示如下：

类与类之间关系的表示

关联关系（Association）

定义：表示类与类之间的联系，可以是单向关联、双向关联或自关联。

单向关联（Unidirectional Association）

类图：类 A 有一个对类 B 的引用。

class Person {
    private Address address;

    public Person(Address address) {
        this.address = address;
    }
}

class Address {
    private String city;
    
    public Address(String city) {
        this.city = city;
    }
}

解释：Person 类知道 Address 类，但 Address 不知道 Person。这是单向关联。

双向关联（Bidirectional Association）

类图：类 A 和类 B 互相引用。

class Person {
    private Address address;

    public Person(Address address) {
        this.address = address;
        address.setPerson(this);
    }
}

class Address {
    private String city;
    
    private Person person;

    public Address(String city) {
        this.city = city;
    }

    public void setPerson(Person person) {
        this.person = person;
    }
}

解释：Person 和 Address 类互相知道对方，这是双向关联。

自关联（Self Association）

类图：类 A 自己引用自己。

class Employee {
    private String name;
    
    private Employee manager;

    public Employee(String name, Employee manager) {
        this.name = name;
        this.manager = manager;
    }
}

解释：Employee 类有一个对自己类型的引用，用于表示雇员和经理的关系。

聚合关系（Aggregation）

定义：表示类与类之间的“部分 - 整体”关系，整体和部分可以独立存在。

class Library {
    private List<Book> books;

    public Library(List<Book> books) {
        this.books = books;
    }
}

class Book {
    private String title;

    public Book(String title) {
        this.title = title;
    }
}

解释：Library 类包含 Book，但 Book 可以独立存在，因此是聚合关系。

组合关系（Composition）

定义：表示类与类之间的“整体 - 部分”关系，部分不能独立于整体存在。

class House {
    private Room room;

    public House() {
        this.room = new Room();
    }
}

class Room {
    public Room() {
        System.out.println("Room is created");
    }
}

解释：House 包含 Room，如果 House 被销毁，Room 也会随之销毁，这就是组合关系。

依赖关系（Dependency）

定义：类与类之间的一种弱关系，一个类使用另一个类的功能，但并不保存对其的长期引用。

class Car {
    public void start(Engine engine) {
        engine.ignite();
    }
}

class Engine {
    public void ignite() {
        System.out.println("Engine started");
    }
}

解释：Car 类依赖于 Engine 类来启动，但并不保存 Engine 的引用。

继承关系（Inheritance）

定义：表示一个类继承另一个类的属性和方法。

class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

解释：Dog 继承了 Animal 类，并重写了 eat() 方法，这是继承关系。

实现关系（Implementation）

定义：表示一个类实现接口中的方法。

interface Drawable {
    void draw();
}

class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

解释：Circle 类实现了 Drawable 接口中的 draw() 方法，这是实现关系。