详解UML中的6大关系(关联、依赖、聚合、组合、泛化、实现)

  转自：http://www.yongfa365.com/Item/UML-Association-Dependency-Aggregation-Composition-Realization-Generalization.html

 大话设计模式上的一个图，我用EA画出来的：
 

UML中的6大关系相关英文及音标：

 依赖关系

 

dependency

 

[di'pendənsi] 关联关系

 

association

 

 [ə,səuʃi'eiʃən] 聚合关系

 

aggregation

 

 [ˌægrɪˈgeɪʃən] 组合关系composition [,kɔmpə'ziʃən] 实现

 

realization

 

 [,ri:əlɪ'zeɪʃən] 泛化

 

generalization

 

 [,dʒenərəlɪ'zeɪʃən]

 

 

UML中的6大关系简单解释：

1. 关联：连接模型元素及链接实例，用一条实线来表示；
2. 依赖：表示一个元素以某种方式依赖于另一个元素，用一条虚线加箭头来表示；
3. 聚合：表示整体与部分的关系，用一条实线加空心菱形来表示；
4. 组成：表示整体与部分的有一关系，用一条实线加实心菱形来表示；
5. 泛化（继承）：表示一般与特殊的关系，用一条实线加空心箭头来表示；
6. 实现：表示类与接口的关系，用一条虚线加空心箭头来表示；

注意：泛化关系和实现关系又统称为一般关系；
总之：一般关系表现为继承或实现(is a)，关联关系、聚合关系、合成/组合关系表现为成员变量(has a)，依赖关系表现为函数中的参数(use a)；

转自：http://www.cnblogs.com/ForEverKissing/archive/2007/12/13/993818.html

UML中的6大关系详细说明：

1、关联关系：
　　含义：类与类之间的连结，关联关系使一个类知道另外一个类的属性和方法；通常含有“知道”，“了解”的含义
体现：在C#中，关联关系是通过成员变量来实现的；
方向：双向或单向；
图示：实线 + 箭头；箭头指向被关联的类；
举例：“渔民”需要知道“天气”情况才能够出海
　　　//公司关联雇员
public class Company
{
    private Employee employee;
    public Employee GetEmployee()
    {
        return employee;
    }
    public void SetEmployee(Employee employee)
    {
        this.employee = employee;
    }
    //公司运作    
    public void Run()
    {
        employee.StartWorking();
    }

}

//A关联B
class A
{
    B b = new B();
}
class B
{
}

2、依赖关系：
　　含义：是类与类之间的连接，表示一个类依赖于另外一个类的定义；依赖关系仅仅描述了类与类之间的一种使用与被使用的关系；
体现：在C#中体现为局部变量、方法/函数的参数或者是对静态方法的调用；
方向：单向；
图示：虚线 + 箭头；
举例：人依赖于水和空气；汽车依赖汽油
　　　　//人划船，人依赖于船
public class Person
{
    //划船
    public void Oarage(Boat boat)
    {
        boat.Oarage();
    }
} 

//A依赖于B
class A
{
    public void Function(B b)
    { }
}
class B
{
}

 

3、聚合关系：
　　含义：是关联关系的一种，是一种强关联关系；聚合关系是整体和个体/部分之间的关系；关联关系的两个类处于同一个层次上，而聚合关系的两个类处于不同的层次上，一个是整体，一个是个体/部分；在聚合关系中，代表个体/部分的对象有可能会被多个代表整体的对象所共享；
体现：C++中，聚合关系通过将被聚合者的（数组）指针作为内部成员来实现的；
方向：单向；
图示：空心菱形 + 实线 + 箭头；箭头指向被聚合的类，也就是说，箭头指向个体/部分；
举例：鸭群与鸭子具有聚合关系；汽车由引擎、轮胎以及其它零件组成，因为汽车坏掉了，没有坏掉的引擎，轮胎和其他零件还可以继续使用。

4、组合关系：
　　含义：它也是关联关系的一种，但它是比聚合关系更强的关系.组合关系要求聚合关系中代表整体的对象要负责代表个体/部分的对象的整个生命周期；组合关系不能共享；在组合关系中，如果代表整体的对象被销毁或破坏，那么代表个体/部分的对象也一定会被销毁或破坏，而在聚合关系中，代表个体/部分的对象则有可能被多个代表整体的对象所共享，而不一定会随着某个代表整体的对象被销毁或破坏而被销毁或破坏；
体现：在C#中，组合关系是通过成员变量来实现的；
方向：单向；
图示：实心菱形 + 实线 + 箭头；箭头指向代表个体/部分的对象，也就是被组合的类的对象；
举例：一个人由头、四肢、等各种器官组成，因为人与这些器官具有相同的生命周期，人死了，这些器官也挂了；

5、泛化关系：
　　含义：它表示一个更泛化的元素和一个更具体的元素之间的关系；也就是通常所说的类的继承关系；
体现：在C#中，泛化关系通过类的继承来实现的；
方向：单向；子类继承父类；
图示：空心箭头 + 实线；箭头指向父类；
举例：动物下面可以分为哺乳动物，脊椎动物，爬行动物等

6、实现关系：
　　含义：它指定了两个实体之间的一份合同；即：一个实体定义一份合同，另外一个实体则保证履行该合同；
体现：在C#中，实现关系通过类实现接口来实现的，即：一个类实现某个接口；
方向：单向；子类实现接口；
图示：空心箭头 + 虚线；箭头指接口向接口；
举例：唐老鸭（对象）会说话（接口），因为一般鸭子不会说话，所以不会将说话这个方法给一般的鸭子带上；超人（对象）会飞（接口）

转自：http://www.cnblogs.com/aicro/archive/2010/08/23/1806584.html

UML中的6大关系参考：

你是我的玫瑰-类关系阐微 
http://www.cnblogs.com/zjzkiss/archive/2007/05/06/736725.html

UML中关联、依赖、聚集等关系的异同
http://www.cnblogs.com/ForEverKissing/archive/2007/12/13/993818.html

UML 类与类之间的关系
http://yanwenhan.javaeye.com/blog/149450

类间的关系
http://www.cnblogs.com/floodpeak/archive/2008/02/27/1083533.html

UML解惑：图说UML中的六大关系
http://developer.51cto.com/art/201004/194204.htm
 

大话设计模式

引用：
详解UML中的6大关系(关联、依赖、聚合、组合、泛化、实现)

http://www.yongfa365.com/item/UML-Association-Dependency-Aggregation-Composition-Realization-Generalization.html

==============================================================================================================

此文为转载文章:http://zjzkiss.cnblogs.com/
世界是普遍联系的，因此程序世界中的类，也不可能是孤立的。UML为我们定义了它们之间的关系，就是：依赖、关联、聚合、组合还有泛化。

       泛化关系比较好理解，就是表示类之间的继承关系。容易混淆的是依赖、关联、聚合和组合的关系。这里做一些甄别：

       1、 依赖和关联的颠倒颠

       在网上查找了一下依赖和关联的区别，有说“关联本身即是一种依赖”，亦有说“依赖是一种弱关联”，其实说来说去是一档子事。依赖和关联都是说一个类用到了另一个类。其区别在于一个是使用，一个是拥有。

      依赖：具有某种偶然性。比如说我要过河，没有桥怎么办，我就去借来一条小船渡过去。我与小船的关系仅仅是使用（借用）的关系。表现在代码上，为依赖的类的某个方法以被依赖的类作为其参数。或者是class A 的某个方法创造了 class B 的实例抑或对class B的静态方法的调用。如果A依赖于B，那意味着B的变化可能要求A也发生变化；

       这是uml图表示的依赖关系：
       
代码表现：

 

1public class Person{    
2    /** 划船 */   
3    public void oarage (Boat boat){    
4        boat.oarage();    
5 }    
6} 
7

 

关联：有名的客户和订单的关系以及公司和员工的关系，都是关联关系。还有就是我和我的单车的例子，他们都是一种“拥有”的关系。表现在代码上，就是一个类包含另一个类的实例，通常表现为被关联类以类属性的形式出现在关联类的类定义中，也可以表现为关联类引用了一个类型为被关联类的全局变量。关联可以使单向的，也可以使双向的。

从网上找到的公司和员工的UML图和代码 ：

公司和员工的关联关系

 1public class Company{    
 2    private Employee employee;    
 3    public Employee getEmployee(){    
 4        return employee;    
 5    }    
 6    public void setEmployee(Employee employee){    
 7        this.employee=employee;    
 8    }    
 9    //公司运作    
10    public void run(){    
11        employee.startWorking();    
12    }    
13}  
14

 

可见依赖于与关联亦有动静之别，关联的类“静态”地引用了被关联类的实例变量，而依赖的偶然性也正说明了它的动态性。

      2、 聚合与组合同出而异体

      聚合与组合其实都是关联的特例，都是整体和部分的关系。他们的区别在于聚合的两个对象之间是可分离的，他们具有各自的生命周期。而组合往往表现为一种唇齿相依的关系。

聚合：一种容纳或曰包含的关系，如同机场和飞机，汽车和轮胎的关系。其实仔细想想，前面的公司和员工的关系也有聚合的味道在里面。

组合：也可称之为强聚合，整体和部分是不可分的，整体的生命周期结束时也就是部分的生命周期到头时。很有名的就是桌子和桌子腿的关系。

      聚合的UML图：

组合的UML图：

 

然而，聚合与组合的代码表现形式是一样的，都可以表现为以下的形式，它们仅仅具有语义上的区别。

网上找到的电脑和CPU的关系的代码表现：

 

 1public class Computer{    
 2    private CPU cpu;    
 3    public CPU getCPU(){    
 4        return cpu;    
 5    }    
 6    public void setCPU(CPU cpu){    
 7        this.cpu=cpu;    
 8    }    
 9    //开启电脑    
10    public void start(){    
11        //cpu运作    
12        cpu.run();    
13    }    
14}  
15

  以上是转自,http://zjzkiss.cnblogs.com/

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

设计模式中类的关系 

在java以及其他的面向对象设计模式中，类与类之间主要有6种关系，他们分别是：依赖、关联、聚合、组合、继承、实现。他们的耦合度依次增强。

1. 依赖（Dependence） 

        依赖关系的定义为：对于两个相对独立的对象，当一个对象负责构造另一个对象的实例，或者依赖另一个对象的服务时，这两个对象之间主要体现为依赖关系。定义比较晦涩难懂，但在java中的表现还是比较直观的：类A当中使用了类B，其中类B是作为类A的方法参数、方法中的局部变量、或者静态方法调用。类上面的图例中：People类依赖于Book类和Food类，Book类和Food类是作为类中方法的参数形式出现在People类中的。

代码样例：

[java] view plaincopy

1. public class People{  
2.     //Book作为read方法的形参  
3.      public void read(Book book){  
4.         System.out.println(“读的书是”+book.getName());  
5.     }  
6. }  

2.关联（Association）、、

单向关联：

 

双向关联：

        对于两个相对独立的对象，当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时，这两个对象之间为关联关系。关联关系分为单向关联和双向关联。在java中，单向关联表现为：类A当中使用了类B，其中类B是作为类A的成员变量。双向关联表现为：类A当中使用了类B作为成员变量；同时类B中也使用了类A作为成员变量。

代码样例：

[java] view plaincopy

1. public class Son{  
2.    //关联关系中作为成员变量的类一般会在类中赋值  
3.     Father father = new Father();  
4.     public void getGift(){  
5.         System.out.println(“从”+father.getName()+”获得礼物”);  
6.     }  
7. }  
8.   
9. public class Father{  
10.     Son son = new Son();  
11.     public void giveGift(){  
12.         System.out.println(“送给”+son.getName()+“礼物”);  
13.     }  
14. }  

3.聚合（Aggregation）

        聚合关系是关联关系的一种，耦合度强于关联，他们的代码表现是相同的，仅仅是在语义上有所区别：关联关系的对象间是相互独立的，而聚合关系的对象之间存在着包容关系，他们之间是“整体-个体”的相互关系。

代码样例：

[java] view plaincopy

1. public class People{  
2.     Car car;  
3.     House house;   
4.     //聚合关系中作为成员变量的类一般使用set方法赋值  
5.      public void setCar(Car car){  
6.         This.car = car;  
7.     }  
8.     public void setHouse(House house){  
9.         This.house = house;  
10.     }  
11.   
12.     public void driver(){  
13.         System.out.println(“车的型号：”+car.getType());  
14.     }  
15.     public void sleep(){  
16.         System.out.println(“我在房子里睡觉：”+house.getAddress());  
17.     }  
18. }  

4.组合（Composition）

        相比于聚合，组合是一种耦合度更强的关联关系。存在组合关系的类表示“整体-部分”的关联关系，“整体”负责“部分”的生命周期，他们之间是共生共死的；并且“部分”单独存在时没有任何意义。在下图的例子中，People与Soul、Body之间是组合关系，当人的生命周期开始时，必须同时有灵魂和肉体；当人的生命周期结束时，灵魂肉体随之消亡；无论是灵魂还是肉体，都不能单独存在，他们必须作为人的组成部分存在。

[java] view plaincopy

1. Public class People{  
2.     Soul soul;  
3.     Body body;   
4.     //组合关系中的成员变量一般会在构造方法中赋值  
5.      Public People(Soul soul, Body body){   
6.         This.soul = soul;  
7.         This.body = body;  
8.     }  
9.   
10.     Public void study(){  
11.         System.out.println(“学习要用灵魂”+soul.getName());  
12.     }  
13.     Public void eat(){  
14.         System.out.println(“吃饭用身体：”+body.getName());  
15.     }  
16. }  

5.继承（Generalization）

        继承表示类与类（或者接口与接口）之间的父子关系。在java中，用关键字extends表示继承关系。UML图例中，继承关系用实线+空心箭头表示，箭头指向父类。

6.实现（Implementation）

         表示一个类实现一个或多个接口的方法。接口定义好操作的集合，由实现类去完成接口的具体操作。在java中使用implements表示。UML图例中，实现关系用虚线+空心箭头表示，箭头指向接口。

        在java中继承使用extends关键字，实现使用implements关键字，很直观。就不代码演示了。

http://blog.csdn.net/zhengzhb/article/details/7187278