依赖、关联、聚合和组合及其之间区别的简单理解

 在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关键字，很直观。

 

        在学习面向对象设计对象关系时，依赖、关联、聚合和组合这四种关系之间区别比较容易混淆。特别是后三种，仅仅是在语义上有所区别，所谓语义就是指上下文环境、特定情景等。他们在编程语言中的体现倒是基本相同的，可是基本相同并不等于彻底相同。

        下面就来详细的论述一下在java中如何准确的体现依赖、关联、聚合和组合。

        首先看一看书上对这四种关系的定义：

• 依赖(Dependency)关系是类与类之间的联接。依赖关系表示一个类依赖于另外一个类的定义。例如，一我的(Person)能够买车(car)和房子(House)，Person类依赖于Car类和House类的定义，由于Person类引用了Car和House。与关联不一样的是，Person类里并无Car和House类型的属性，Car和House的实例是以参量的方式传入到buy()方法中去的。通常而言，依赖关系在Java语言中体现为局域变量、方法的形参，或者对静态方法的调用。
• 关联(Association）关系是类与类之间的联接，它使一个类知道另外一个类的属性和方法。关联能够是双向的，也能够是单向的。在Java语言中，关联关系通常使用成员变量来实现。
•  聚合(Aggregation) 关系是关联关系的一种，是强的关联关系。聚合是总体和个体之间的关系。例如，汽车类与引擎类、轮胎类，以及其它的零件类之间的关系便总体和个体的关系。与关联关系同样，聚合关系也是经过实例变量实现的。可是关联关系所涉及的两个类是处在同一层次上的，而在聚合关系中，两个类是处在不平等层次上的，一个表明总体，另外一个表明部分。
•  组合(Composition) 关系是关联关系的一种，是比聚合关系强的关系。它要求普通的聚合关系中表明总体的对象负责表明部分对象的生命周期，组合关系是不能共享的。表明总体的对象须要负责保持部分对象和存活，在一些状况下将负责表明部分的对象湮灭掉。表明总体的对象能够将表明部分的对象传递给另外一个对象，由后者负责此对象的生命周期。换言之，表明部分的对象在每个时刻只能与一个对象发生组合关系，由后者排他地负责生命周期。部分和总体的生命周期同样。

——摘自《Java面向对象编程》，做者：孙卫琴

       以上关系的耦合度依次加强（关于耦合度的概念将在之后具体讨论，这里能够暂时理解为当一个类发生变动时，对其余类形成的影响程度，影响越小则耦合度越弱，影响越大耦合度越强）。由定义咱们已经知道，依赖关系其实是一种比较弱的关联，聚合是一种比较强的关联，而组合则是一种更强的关联，因此笼统的来区分的话，实际上这四种关系、都是关联关系。

        依赖关系比较好区分，它是耦合度最弱的一种，在java中表现为局域变量、方法的形参，或者对静态方法的调用，以下面的例子：Driver类依赖于Car类，Driver的三个方法分别演示了依赖关系的三种不一样形式。

[java] view plaincopy

1. class Car {  
2.     public static void run(){  
3.         System.out.println("汽车在奔跑");  
4.     }  
5. }  
6.   
7. class Driver {  
8.     //使用形参方式发生依赖关系  
9.     public void drive1(Car car){  
10.         car.run();  
11.     }  
12.     //使用局部变量发生依赖关系  
13.     public void drive2(){  
14.         Car car = new Car();  
15.         car.run();  
16.     }  
17.     //使用静态变量发生依赖关系  
18.     public void drive3(){  
19.         Car.run();  
20.     }  
21. }  

        关联关系在java中通常使用成员变量来实现，有时也用方法形参的形式实现。依然使用Driver和Car的例子，使用方法参数形式能够表示依赖关系，也能够表示关联关系，毕竟咱们没法在程序中太准确的表达语义。在本例中，使用成员变量表达这个意思：车是我本身的车，我“拥有”这个车。使用方法参数表达：车不是个人，我只是个司机，别人给我什么车我就开什么车，我使用这个车。

[java] view plaincopy

1. class Driver {  
2.     //使用成员变量形式实现关联  
3.     Car mycar;  
4.     public void drive(){  
5.         mycar.run();  
6.     }  
7.     ...  
8.     //使用方法参数形式实现关联  
9.     public void drive(Car car){  
10.         car.run();  
11.     }  
12. }  

        聚合关系是是一种比较强的关联关系，java中通常使用成员变量形式实现。对象之间存在着总体与部分的关系。例如上例中

[java] view plaincopy

1. class Driver {  
2.     //使用成员变量形式实现聚合关系  
3.     Car mycar;  
4.     public void drive(){  
5.         mycar.run();  
6.     }  
7. }  

        假如给上面代码赋予以下语义：车是一辆私家车，是司机财产的一部分。则相同的代码即表示聚合关系了。聚合关系通常使用setter方法给成员变量赋值。

假如赋予以下语义：车是司机的必须有的财产，要想成为一个司机必需要先有辆车，车要是没了，司机也不想活了。并且司机要是不干司机了，这个车就砸了，别人谁也别想用。那就表示组合关系了。通常来讲，为了表示组合关系，经常会使用构造方法来达到初始化的目的，例如上例中，加上一个以Car为参数的构造方法

[java] view plaincopy

1. public Driver(Car car){  
2.     mycar = car;  
3. }  

        因此，关联、聚合、组合只能配合语义，结合上下文才可以判断出来，而只给出一段代码让咱们判断是关联，聚合，仍是组合关系，则是没法判断的。