六种常用UML关系（代码实例）

依赖（Dependence）

• 表示一个类依赖于另一个类的定义。依赖关系总是单向的。
• 简单的理解，就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是B类的变化会影响到A。
• 在代码层面，表现为类B作为参数被类A在某个method方法中使用。具体体现为局部变量、方法中的参数、静态方法的调用等。

代码实例：

public class Book {

    private String name;

    public Book() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

public class Food {

    private String name;

    public Food() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

public class People {

    private String name;

    public People(String name) {
        this.name = name;
    }

    //Dependency
    public void eat(Food food){
        System.out.println("eat " + food.getName());
    }

    //Dependency
    public void read(Book book){
        System.out.println("read " + book.getName());
    }

}

public class Main {

    public static void main(String[] args) {
        People people = new People("White");
        Food food = new Food();
        food.setName("seafood");
        Book book = new Book();
        book.setName("cs");
        people.eat(food);
        people.read(book);
    }

}

以上代码中People类依赖Food类和Book类，这种依赖关系表现为Food类和Book类作为People类中方法的参数，局部变量和静态方法调用的情况也比较简单，此处省略。

关联（Association）

• 表示类与类之间的联接, 它使一个类知道另一个类的属性和方法。
• 关联可以使用单箭头表示单向关联, 使用双箭头或不使用箭头表示双向关联, 不建议使用双向关联.。关联有两个端点, 在每个端点可以有一个基数, 表示这个关联的类可以有几个实例。
• 单向关联表现为类A当中使用了类B，其中类B是作为类A的成员变量。双向关联表现为类A当中使用了类B作为成员变量，同时类B中也使用了类A作为成员变量。

代码实例：

public class Father {

    //Association
    private Son son;

    public Father() {
    }

    public void giveGift(){
        System.out.println("father gives a gift to son");
    }

    public Son getSon() {
        return son;
    }

    public void setSon(Son son) {
        this.son = son;
    }

}

public class Son {

    //Association
    private Father father;

    public Son() {
    }

    public void getGift(){
        System.out.println("son gets a gift from father");
    }

    public Father getFather() {
        return father;
    }

    public void setFather(Father father) {
        this.father = father;
    }

}

public class Main {

    public static void main(String[] args) {
        Father father = new Father();
        Son son = new Son();
        father.setSon(son);
        son.setFather(father);
        father.giveGift();
        son.getGift();
    }

}

以上代码中Father类和Son类相互关联，各自使用对方作为自己的成员变量。

聚合（Aggregation）

• 聚合是关联关系的一种特例，耦合性比关联关系更强。
• 聚合表示的是整体与个体之间的关系，即has-a的关系。
• 整体与个体之间是可以分离的，他们各自有自己的生命周期。
• 它和关联关系的区别在于，关联关系的两个类是同等级别的，而聚合关系中有整体和个体的区分。

代码实例：

public class House {

    private String address;

    public House(String address) {
        this.address = address;
    }

    public void getHouseAddress(){
        System.out.println(this.address);
    }

}

public class Car {

    private String brand;

    public Car(String brand) {
        this.brand = brand;
    }

    public void getCarBrand(){
        System.out.println(this.brand);
    }

}

public class People {

    private House house;
    private Car car;

    public People() {
    }

    public void showAssets(){
        house.getHouseAddress();
        car.getCarBrand();
    }

    public House getHouse() {
        return house;
    }

    public void setHouse(House house) {
        this.house = house;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

}

public class Main {

    public static void main(String[] args) {
        House house = new House("Central Park");
        Car car = new Car("Ford");
        People p = new People();
        p.setCar(car);
        p.setHouse(house);
        p.showAssets();
    }

}

以上代码中People类和House类、Car类是一个整体与个体的关系，它们都有各自的生命周期，是一种聚合关系。

组合（Composition）

• 组合关系也是关联关系的一种特例，耦合性比聚合关系更强，它体现的是整体与部分的关系，表现为contains-a。整体和部分是不可分割的，要么同生，要么共死。

代码实例：

public class Body {

    public Body() {
    }

    public void showBody(){
        System.out.println("body");
    }

}

public class Soul {

    public Soul() {
    }

    public void showSoul(){
        System.out.println("soul");
    }

}

public class People {

    private Body body;
    private Soul soul;

    public People(Body body,Soul soul) {
        this.body = body;
        this.soul = soul;
    }

    public void print(){
        body.showBody();
        soul.showSoul();
    }

}

public class Main {

    public static void main(String[] args) {
        People people = new People(new Body(),new Soul());
        people.print();
    }

}

以上代码中，People类和Body类、Soul类是整体与部分的关系，它们同生同死，不能分离单独存在。比如，这边Body和Soul都是在People的构造函数中实例化的，表示同生，且不能更换。而在前面的聚合关系中，People的House和Car是可以随时更换的。

继承/泛化（Generalization）

• 表示类与类（或者接口与接口）之间的父子关系。

代码实例：

public class Animal {

    public Animal() {
    }

    public void makSound(){
        System.out.println("Animal make sound!");
    }

}

public class Human extends Animal{

    public Human() {
    }

    @Override
    public void makSound() {
        System.out.println("Human make sound!");
    }

}

public class Main {

    public static void main(String[] args) {
        Animal peter = new Human();
        peter.makSound();
    }

}

实现（Implementation）

• 表示一个类实现一个或多个接口的方法，接口定义好操作的集合，由实现类去完成接口的具体操作。

代码实例：

public interface Animal {

    public void eat();
    public void move();

}

public class Human implements Animal {

    public Human() {
    }

    @Override
    public void eat() {
        System.out.println("Human eat...");
    }

    @Override
    public void move() {
        System.out.println("Human move...");
    }

}

public class Main {

    public static void main(String[] args) {
        Animal mason = new Human();
        mason.eat();mason.move();
    }

}

结束。