委以、关联、聚合、组合还有泛化的关系

 

单向关联

两 个类是相关的，但是只有一个类知道这种联系的存在

BankAccount.java

public class BankAccount {

}

OverdrawnReport.java

public class OverdrawnReport {

         private BankAccount overdrawnReports;

}

 双向关联

两 个类彼此知道它们间的联系

Job.java

public class Job {

         private Person jobs;

}

Person.java

public class Person {

         private Job persons;

}

Person类 的多重值描述0…1表示，当一个Job实体 存在时，可以有一个或没有Person与之关联（也就是，Person可 能还没有被分配）。Person知道它与Job类 的关联。Person实体可以不与Job关 联（例如，人没有工作）或没有上限的Job（例如，一个工作有很多人干）关联。

关联类

User.java

public class User {

}

Goods.java

public class Goods {

}

Record.java

public class Record {

         private User user;

         private Goods goods;

}

聚合

1: 基本聚合

Employee.java

public class Employee {

}

Company.java

public class Company {

         private Employee employees;

}

2 .组合聚合

Heart.java

public class Heart {

}

Human.java

public class Human{

         private Heart heart = new Heart();

}

基 本聚合和组合聚合的区别:

基 本聚合例子:公司和员工的关系,开 了一个新公司,但不一定要招员工,员 工可以单独存在.

组 合聚合例子:当人出生的时候,同 时人就有了心脏,心脏脱离了人就没有意义了.

反射

Human.java

public class Human {

         ArrayList friends = new ArrayList();

        public void makeFriend(Human human)

        {

friends.add(human);

       }

}

依赖

某个对象的功能依赖于另外的某个对象，而被依赖的对象只是作为一种工具在使用，而并不持有对它的引用。

Air.java

public class Air {

}

Human.java

public class Human {

         public void breath(Air air) {

         }

}

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

UML图示例：(可使用 StartUML来画图,小巧^_^)

generalization

 

实现 realization.

 

依赖,关联,聚合和组合

1.实例化(依赖)
A将B作为局部变量进行使用.
程序1
void A::foo()
{
B b;
b.SomeMethod();
}

关联
A与B存在一定的关系. 这里只考虑单向导航. 关联在代码中有多种表现形式.
第一种, 作为参数:
程序2
void A::foo(B& b) // (B* b) or (B b)
{
b.SomeMethod();
}

第二种, 作为成员变量:
程序3
class A
{
public:
A(B& b)
{
b_ = b;
}

void foo()
{
b_.SomeMethod();
}
private:
B& b_; // B* b_
};

聚合
聚合是一种特殊的关联, 聚合更明确指出聚合的主体具有整体-部分关系. 代码的表现形式见程序3.

 

组合
组合是一种特殊的聚合, 组合中的某个主体控制着另外一个主体的生命周期,而且他们还存在整体-部分关系.
程序4
class A
{
public:
A()
{
b_ = new B;
}

~A()
{
delete b_;
b_ = NULL;
}

void foo()
{
b_->SomeMethod();
}
private:
B* b_;
};

 

UML中聚合和组合的关系

聚合：指的是整体与部分的关系。通常在定义一个整 体类后，再去分析这个整体类的组成结构。从而找出一些组成类，该整体类和组成类之间就形成了聚合关系。例如一个航母编队包括海空母舰、驱护舰艇、舰载飞机 及核动力攻击潜艇等。需求描述中“包含”、“组成”、“分为…部分”等词常意味着聚合关系。

组合：也表示类之间整体和部分的关系，但是组合关系中部分和整体具有统一的生存期。一旦整体对象不存在，部分对象也将不存在。部分对象与整体对象之间具有 共生死的关系。

聚合和组合的区别在于：聚合关系是“has-a” 关系，组合关系是“contains-a”关系；聚合关系表示整体与部分的关系比较弱，而组合比较强；聚合关系中代表部分事物的对象与代表聚合事物的对象 的生存期无关，一旦删除了聚合对象不一定就删除了代表部分事物的对象。组合中一旦删除了组合对象，同时也就删除了代表部分事物的对象。

我们用浅显的例子来说明聚合和组合的区别。“国破 家亡”，国灭了，家自然也没有了，“国”和“家”显然也是组合关系。而相反的，计算机和它的外设之间就是聚合关系，因为它们之间的关系相对松散，计算机没 了，外设还可以独立存在，还可以接在别的计算机上。在聚合关系中，部分可以独立于聚合而存在，部分的所有权也可以由几个聚合来共享，比如打印机就可以在办 公室内被广大同事共用

关联和聚合的区别主要在语义上，关联的两个对象之间一般是平等的，例如你是我的朋友，聚合则一般不是平等的，例 如一个公司包含了很多员工，其实现上是差不多的。聚合和组合的区别则在语义和实现上都有差别，组合的两个对象之间其生命期有很大的关联，被组合的对象是在 组合对象创建的同时或者创建之后创建，在组合对象销毁之前销毁。一般来说被组合对象不能脱离组合对象独立存在，而且也只能属于一个组合对象，例如一个文档 的版本，必须依赖于文档的存在，也只能属于一个文档。聚合则不一样，被聚合的对象可以属于多个聚合对象，例如一个员工可能可以属于多个公司。

我想举个通俗的例子。
你和你的心脏之间是composition关系（心脏只属于你自己）
你和你买的书之间是aggregation关系（书可能是别人的）
你和你的朋友之间是association关系

 

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

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

1、 依赖和关联的颠倒颠
依赖(dependency)是两个事物间的语义关系，其中一个事物(独立事物)发生变化会影响另一个事物(依赖事物)的语义。在图形上，把一个依 赖画成一条可能有方向的虚线
在网上查找了一下依赖和关联的区别，有说“关联本身即是一种依赖”，亦有说“依赖是一种弱关联”，其实说来说去是一档子事。依赖和关联都是说一个类用到了另一个类。其区别在于一个是使用，一个是拥有。

依赖：具有某种偶然性。比如说我要过河，没有桥怎么办，我就去借来一条小船渡过去。我与小船的关系仅仅是使用（借用）的关系。表现在代码上，为依赖的类的某个方法以被依赖的类作为其参数。或者是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

 

类的关系  

 

 

泛化（generalization）：即继承

Animal.java

public class Animal {

}

bird.java

public class bird extends Animal {

}