设计模式中的关系

一、依赖

概念

依赖是一种临时使用关系，代码层体现为作为参数。

具体体现：依赖者调用被依赖者的局部变量、参数、静态方法；

例子：人类（Human）的生存（live）依赖于食物（Food）

UML类图

代码实现

public class Human{
	public void live(Food food){
		food.eat();
	}
}
class Food{
	public void eat(){
        System.out.println("吃东西");
    }
}

二，关联

概念

关联是一个对象使用另一对象或与另一对象进行交互的关系。可以是双向，也可以是单向。

关联可视为一种特殊类型的依赖，即一个对象总是拥有访问与其交互的对象的权限，而简单的依赖关系并不会在对象间建立永久性的联系。

具体体现：关联的对象作为一个对象的成员变量

UML类图

代码实现

public class Human{
	private Food food;
	public void live(){
		food.eat();
	}
}
class Food{
	public void eat(){
		System.out.println("吃东西");
	}
}

三、聚合

概念

聚合是一种特殊的关联，表示整体对象拥有部分对象，整体和部分生命周期没有必然联系，聚合关系代码层体现也是通过成员变量来体现

聚合是一种特殊类型的关联，用于表示多个对象之间的“一对多”、“多对多”或“整体对部分”的关系。通常在聚合关系中，一个对象“拥有”一组其他对象，并扮演着容器或集合的角色。

UML类图：

具体体现：被聚合对象作为成员变量

例子：人体主要是由水、血液和肌肉聚合成的

代码实现：

public class Human{
	private Blood blood;
	private Water water;
	private Muscles muscles;
	public void body(Blood blood,Water water,Muscles muscles){
		this.blood=blood;
		this.water=water;
		this.muscles=muscles;
	}
}
class Blood{

}
class Water{

}
class Muscles{

}

四、组合

概念

比聚合更强的关联关系；组合是一种特殊类型的聚合，其中一个对象由一个或多个其他对象实例构成。组合与其他关系的区别在于组件仅能作为容器的一部分存在。

具体体现：个体对象作为成员变量

例子： 人和人的心脏、大脑

UML类图

代码实现

public class Human {
    private Brain brain;
    private Heart heart;
    private String status;

    public void sustainLife() {
        brain.control(status);
        heart.beat(status);
    }

    public Human(Brain brain, Heart heart, String status) {
        this.brain = brain;
        this.heart = heart;
        this.status = status;
    }
}

class Brain {
    public void control(String status) {
        if (status.equals("0")) {
            System.out.println("脑死亡");
        } else {
            System.out.println("大脑控制身体");
        }
    }
}

class Heart {
    public void beat(String status) {
        if (status.equals("0")) {
            System.out.println("心跳停止");
        } else {
            System.out.println("心脏跳动");
        }
    }
}

五、实现

概念

实现，定义一个合约，另一个实体履行合约，实现了一个接口。implements

例子： 引擎，有汽车的引擎，有卡车的引擎

UML类图

代码实现：

interface Functionality{
	
	void engines();
}

class Cars implements Functionality{

	@Override
	public void engines() {
		System.out.println("汽车的引擎");
	}
}

class Trucks implements Functionality{

	@Override
	public void engines() {
		System.out.println("卡车的引擎");	
	}
}

六、继承

概念

继承，子类和父类之间的关系，用于代码扩展，extends。

例子：动物类，包含猫和狗，动物类定义功能，猫狗也各自定义自己的功能

UML类图

代码实现：

abstract class Animal {
	abstract void functionality();
}
class Cat extends Animal {

	@Override
	void functionality() {
		System.out.println("猫的功能是上树");
	}
}

class Dog extends Animal {

	@Override
	void functionality() {
		System.out.println("狗的功能是力气大");
	}
}

图总结

• 依赖：对类 B 进行修改会影响到类 A 。
• 关联：对象 A 知道对象 B。类 A 依赖于类 B。
• 聚合：对象 A 知道对象 B 且由 B 构成。类 A 依赖于类 B。
• 组合：对象 A 知道对象 B、由 B 构成而且管理着 B 的生命周期。类 A 依赖于类 B。
• 实现：类 A 定义的方法由接口 B 声明。对象 A 可被视为对象B。类 A 依赖于类 B。
• 继承： 类 A 继承类 B 的接口和实现， 但是可以对其进行扩展。对象 A 可被视为对象 B。类 A 依赖于类 B。

整体总结

一、依赖是一种临时使用关系，代码层体现为作为参数。

二、关联是结构关系，表示两个对象相联系。代码层体现为作为成员变量使用，即属性。

三、聚合是一种特殊的关联，表示整体对象拥有部分对象，整体和部分生命周期没有必然联系，聚合关系代码层体现也是通过成员变量来体现

四、组合，整体和部分生命周期是一致的（实心菱形），也是通过类的成员变量来实现。

五、实现，定义一个合约，另一个实体履行合约，实现了一个接口。

六、继承，子类和父类之间的关系，用于代码扩展，extends。