UML类图关系及其对应代码

0.引言

该博客写得非常好，大部分转载自该博客，以防备忘，同时加了点内容并用C++表示了一下，全都是重复造轮子，厚着脸皮标原创吧。

• ref01.UML中泛化 , 实现 , 关联, 聚合, 组合, 依赖
• ref02.UML类图符号 各种关系说明以及举例

1.UML类图关系总览

文字解释下各个类及关系

类	含义及关系
Food类	食物类，People类依赖Food类
Adress类	地址类，People类关联Address类
PeopleGroup类	人群类，PeopleGroup类聚合People类
Heart类	心脏类，Hear类组合成People类
Animal类	动物类，People类继承Animal类
Eatting接口	People类实现此接口

• 关系耦合度：继承(泛化)=实现>组合>聚合>关联>依赖

下面依关系耦合度角度，从低向高依次介绍并给出对象的代码

2.依赖关系

1.关系描述

• 定义: 类之间的使用关系，即Use a，一个类使用了另一个类，或者一个类依赖另一个类的服务

• 类A依赖于类B，类B可以作为类A方法的参数、局部变量、方法返回值类型
  或者类A方法中调用类B的静态方法
  类A方法中有类B类型的变量

2.举例

People类想要完成eat方法，需要使用Food类，即需要Food类提供getName方法作为服务

Class People{
	//Food类作为eat方法的参数
	public void eat(Food food){
		std::cout<<"正在吃的食物是"<<food.getName())<<std::endl;
	}
}

3.关联关系

1.关系描述

• 定义 : 表示类拥有另一个类，可以表示为has a
• 类A关联类B，类B作为类A的成员变量
  

2.举例
每一个People对象都有一个联系地址

Class People{
	//Address类作为成员变量
	private Address address_;
}

3.思考 : 为什么依赖比关联的耦合度低？

• 依赖对应对象方法的局部变量，关联对应对象的成员变量。
• 成员变量和对象具有相同的生命周期，即类A一直和类B存在关联关系
• 局部变量只有在方法被调用时，类A才会和类B存在依赖关系
• 因此从关系存在的时间长短可以推断出依赖比关联耦合度低

4.聚合、组合关系——关联关系的两种形式

1.关系描述

• 聚合 : 描述两个类之间存在“整体—部分”关系，部分类生命周期取决于本身，比关联关系耦合度高
• 组合 : 是聚合的特殊情况，也是"整体—部分"关系，部分类生命周期取决于整体，比聚合耦合度高

2.两者关系对比

有的聚合\组合关系也标注数字比例：

聚合：

Class PeopleGroup
{
	Public:
		PeopleGroup(People people)
			: people_(people){}
	//People 作为类成员变量
	private：
		People people_;
}

组合：

Class People
{
public:
	People()
	{
		heart_ = new Heart();
	}
private:
	//Heart 类作为成员变量
	Heart heart_;
}

3.关系比较

• 共同点 ："部分"类作为"整体"类的成员变量，成员变量类型也可以是"部分"类型的数组
• 不同点：构造函数不同。
  • 聚合："整体"类包含"部分"类作为参数，PeopleGroup类的构造函数要用到People类型的参数，People类可以脱离PeopleGroup类独立存在，即部分可以脱离整体独立存在。
  • 组合："整体"类包含"部分"类的实例化，在People类实例化之前一定要先实例化Heart(心脏)类，Heart类不可以脱离People类独立存在，即部分不能独立存在

5.继承(泛化)关系

1.关系描述

• 子类继承父类的属性和方法，除私有成员和构造函数外
• 关系描述为is a，比如人是一个动物
• 子类继承父类，父类泛化子类

2.举例

class People : public Animal{
}

3.思考：合成(聚合)复用原则由来

此原则本质便为：为什么少用继承关系多用组合(合成)聚合关系

• 1.子类继承父类公有和受保护的所有方法，即使父类方法是有害或者对子类无用
• 2.耦合度高，父类变化也会引起子类变化，也可能造成类体系无限膨胀
• 3.继承的子类，实际上需要编译期确定下来，这满足不了需要在运行内才能确定对象的情况。而组合却可以比继承灵活得多，可以在运行期才决定某个对象。 对这句话理解：子类要想实例化其父类必先实例化，因此要实例的对象在编译时已经确定，不能够动态生成指定对象

组合聚合关系是结构型设计模式的核心，典型的设计模式有代理模式，适配器模式，装饰模式等

五、实现关系

关系描述及举例

• 类实现接口，实现与泛化关系耦合度相同，下面看例子
• 如People类实现了Eating接口，并重写了eat方法

class People implements Eating(){
	//重写的方法，接口的方法就不写了，哈哈
	public void eat(Food food){
		System.out.println("正在吃的食物是"+food.getName())
	}
}

6.最后总结

• 关系耦合度：继承(泛化)=实现>组合>聚合>关联>依赖

UML图

code：

//uml.h
#ifndef _UML_H_
#define _UML_H_
#include <iostream>
#include <string>
using namespace std;

class Animal{
private:
public:
    Animal();
    ~Animal();
};

class Address{
private:
public:
    Address();
    ~Address();
};

class Food{
private:
    string name_ = "苹果";
public:
    Food();
    ~Food();
    string GetFood() {return name_;}
};

class Heart{
private:
    /* data */
public:
    Heart(/* args */);
    ~Heart();
};

class Eatting
{
private:
    /* data */
public:
    Eatting();
    ~Eatting();
    virtual void eat(Food food) = 0;
};

// 继承 ： "is a" 关系
class People : public Animal ,public Eatting{
private:
    // 关联（拥有关系 -- 人拥有地址） ： Address类作为成员变量
	Address address_;
    // 组合（整体与部分关系 -- 心脏是人的一部分） ： Heart 类作为成员变量
	Heart heart_;
    // 属性 ： 人名
    string name_;
public:
    People(/* args */);
    ~People();
    // 依赖 (使用关系 -- People类使用Food类) ： Food类为People类eat()方法的参数
    // 重写， 这里也是接口的实现？
    void eat(Food food)
    {
        std::cout<<name_ <<"正在吃"<<food.GetFood()<<std::endl;
    }
};

class PeopleGroup{
public:
private:
    // 聚合（整体与部分关系 -- 人是人群的一部分）People 作为类成员变量
    People people_;
}；

#endif