关键字: 依赖关联泛化实现
UML中有4种关系：依赖、关联、泛化和实现。
(1)依赖(dependency)是两个事物间的语义关系，其中一个事物(独立事物)发生变化会影响另一个事物(依赖事物)的语义。在图形上，把一个依赖画成一条可能有方向的虚线。
(2)关联(association)是一种结构关系，它描述了一组链，链是对象之间的连接。聚集(aggregation)是一种特殊类型的关联，它描 述了整体和部分间的结构关系。关联和聚集的图形化表示如图1 O一1 3和图1 O一1 4所示。在关联上可以标注重复度(multiplicity)和角色(role)。
(3)泛化(generalization)是一种特殊／一般关系，特殊元素(子元素)的对象可替代一般元素(父元素)的对象，用这种方法，子元素共享了 父元素的结构和行为。在图形上，把一个泛化关系画成一条带有空心箭头的实线，它指向父元素，如图1 O一1 5所示。
(4)实现(realization)是类元之间的语义关系，其中一个类元指定了由另一个类元保证执行的契约。在两种地方要遇到实现关系：一种是在接口和 实现它们的类或构件之间；另一种是在用例和实现它们的协作之间。在图形上，把一个实现关系画成一条带有空心箭头的虚线。
这4种关系是U ML模型中可以包含的基本关系事物。它们也有变体，例如，依赖的变体有精化、跟踪、包含和延伸。
泛化(继承)
class A{
}
class B : A{
}
依赖：
class A{
public void Function(B b)
{}
}
class B {
}
关联
class A{
B b = new B();
}
class B {
}
聚合
class A{
B b = new B();
C c = new C();
}
class B {
}
class C {
}
组合
class A{
B b = new B();
C c = new C();
}
class B {
}
class C {
}
聚合和组合的区别：生命周期。
组合中，随着A类的生命周期结束，B,C也结束。必须在A类里面使用。
聚合中，随着A类的生命周期结束，B,C不一定结束。
资料三：
1 类的关系
2 泛化（generalization）：即继承
Animal.java
public class Animal {
}
bird.java
public class bird extends Animal {
}
3 关联（association）
3.1 单向关联
两个类是相关的，但是只有一个类知道这种联系的存在
BankAccount.java
public class BankAccount {
}
OverdrawnReport.java
public class OverdrawnReport {
private BankAccount overdrawnReports;
}
3.2 双向关联
两个类彼此知道它们间的联系
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（例如，一个工作有很多人干）关 联。
3.3 关联类
User.java
public class User {
}
Goods.java
public class Goods {
}
Record.java
public class Record {
private User user;
private Goods goods;
}
3.4 聚合
3.4.1 基本聚合
Employee.java
public class Employee {
}
Company.java
public class Company {
private Employee employees;
}
3.4.2 组合聚合
Heart.java
public class Heart {
}
Human.java
public class Human{
private Heart heart = new Heart();
}
基本聚合和组合聚合的区别:
基本聚合例子:公司和员工的关系,开了一个新公司,但不一定要招员工,员工可以单独存在.
组合聚合例子:当人出生的时候,同时人就有了心脏,心脏脱离了人就没有意义了.
3.5 反射
Human.java
public class Human {
ArrayList friends = new ArrayList();
public void makeFriend(Human human)
{
friends.add(human);
}
}
4 依赖
某个对象的功能依赖于另外的某个对象，而被依赖的对象只是作为一种工具在使用，而并不持有对它的引用。
Air.java
public class Air {
}
Human.java
public class Human {
public void breath(Air air) {
}
}
--------------------------------------------------------------------------------------------
UML图示例：(可使用StartUML来画图,小巧^_^)
generalization
2.实现realization.
二、依赖,关联,聚合和组合
1.实例化(依赖)
A将B作为局部变量进行使用.
程序1
void A::foo()
{
B b;
b.SomeMethod();
}
2.关联
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.聚合
聚合是一种特殊的关联, 聚合更明确指出聚合的主体具有整体-部分关系. 代码的表现形式见程序3.
4.组合
组合是一种特殊的聚合, 组合中的某个主体控制着另外一个主体的生命周期,而且他们还存在整体-部分关系.
程序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”关系；聚合关系表示整体与部分的关系比较弱，而组合比 较强；聚合关系中代表部分事物的对象与代表聚合事物的对象的生存期无关，一旦删除了聚合对象不一定就删除了代表部分事物的对象。组合中一旦删除了组合对 象，同时也就删除了代表部分事物的对象。
我们用浅显的例子来说明聚合和组合的区别。“国破家亡”，国灭了，家自然也没有了，“国”和“家”显然也是组合关系。而相反的，计算机和它的外设 之间就是聚合关系，因为它们之间的关系相对松散，计算机没了，外设还可以独立存在，还可以接在别的计算机上。在聚合关系中，部分可以独立于聚合而存在，部 分的所有权也可以由几个聚合来共享，比如打印机就可以在办公室内被广大同事共用
关联和聚合的区别主要在语义上，关联的两个对象之间一般是平等的，例如你是我的朋友，聚合则一般不是平等的，例如一个公司包含了很多员工，其实 现上是差不多的。聚合和组合的区别则在语义和实现上都有差别，组合的两个对象之间其生命期有很大的关联，被组合的对象是在组合对象创建的同时或者创建之后 创建，在组合对象销毁之前销毁。一般来说被组合对象不能脱离组合对象独立存在，而且也只能属于一个组合对象，例如一个文档的版本，必须依赖于文档的存在， 也只能属于一个文档。聚合则不一样，被聚合的对象可以属于多个聚合对象，例如一个员工可能可以属于多个公司。
(1)依赖(dependency)是两个事物间的语义关系，其中一个事物(独立事物)发生变化会影响另一个事物(依赖事物)的语义。在图形上，把一个依赖画成一条可能有方向的虚线。
(2)关联(association)是一种结构关系，它描述了一组链，链是对象之间的连接。聚集(aggregation)是一种特殊类型的关联，它描 述了整体和部分间的结构关系。关联和聚集的图形化表示如图1 O一1 3和图1 O一1 4所示。在关联上可以标注重复度(multiplicity)和角色(role)。
(3)泛化(generalization)是一种特殊／一般关系，特殊元素(子元素)的对象可替代一般元素(父元素)的对象，用这种方法，子元素共享了 父元素的结构和行为。在图形上，把一个泛化关系画成一条带有空心箭头的实线，它指向父元素，如图1 O一1 5所示。
(4)实现(realization)是类元之间的语义关系，其中一个类元指定了由另一个类元保证执行的契约。在两种地方要遇到实现关系：一种是在接口和 实现它们的类或构件之间；另一种是在用例和实现它们的协作之间。在图形上，把一个实现关系画成一条带有空心箭头的虚线。
这4种关系是U ML模型中可以包含的基本关系事物。它们也有变体，例如，依赖的变体有精化、跟踪、包含和延伸。
泛化(继承)
class A{
}
class B : A{
}
依赖：
class A{
public void Function(B b)
{}
}
class B {
}
关联
class A{
B b = new B();
}
class B {
}
聚合
class A{
B b = new B();
C c = new C();
}
class B {
}
class C {
}
组合
class A{
B b = new B();
C c = new C();
}
class B {
}
class C {
}
聚合和组合的区别：生命周期。
组合中，随着A类的生命周期结束，B,C也结束。必须在A类里面使用。
聚合中，随着A类的生命周期结束，B,C不一定结束。
资料三：
1 类的关系
2 泛化（generalization）：即继承
Animal.java
public class Animal {
}
bird.java
public class bird extends Animal {
}
3 关联（association）
3.1 单向关联
两个类是相关的，但是只有一个类知道这种联系的存在
BankAccount.java
public class BankAccount {
}
OverdrawnReport.java
public class OverdrawnReport {
private BankAccount overdrawnReports;
}
3.2 双向关联
两个类彼此知道它们间的联系
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（例如，一个工作有很多人干）关 联。
3.3 关联类
User.java
public class User {
}
Goods.java
public class Goods {
}
Record.java
public class Record {
private User user;
private Goods goods;
}
3.4 聚合
3.4.1 基本聚合
Employee.java
public class Employee {
}
Company.java
public class Company {
private Employee employees;
}
3.4.2 组合聚合
Heart.java
public class Heart {
}
Human.java
public class Human{
private Heart heart = new Heart();
}
基本聚合和组合聚合的区别:
基本聚合例子:公司和员工的关系,开了一个新公司,但不一定要招员工,员工可以单独存在.
组合聚合例子:当人出生的时候,同时人就有了心脏,心脏脱离了人就没有意义了.
3.5 反射
Human.java
public class Human {
ArrayList friends = new ArrayList();
public void makeFriend(Human human)
{
friends.add(human);
}
}
4 依赖
某个对象的功能依赖于另外的某个对象，而被依赖的对象只是作为一种工具在使用，而并不持有对它的引用。
Air.java
public class Air {
}
Human.java
public class Human {
public void breath(Air air) {
}
}
--------------------------------------------------------------------------------------------
UML图示例：(可使用StartUML来画图,小巧^_^)
generalization
2.实现realization.
二、依赖,关联,聚合和组合
1.实例化(依赖)
A将B作为局部变量进行使用.
程序1
void A::foo()
{
B b;
b.SomeMethod();
}
2.关联
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.聚合
聚合是一种特殊的关联, 聚合更明确指出聚合的主体具有整体-部分关系. 代码的表现形式见程序3.
4.组合
组合是一种特殊的聚合, 组合中的某个主体控制着另外一个主体的生命周期,而且他们还存在整体-部分关系.
程序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”关系；聚合关系表示整体与部分的关系比较弱，而组合比 较强；聚合关系中代表部分事物的对象与代表聚合事物的对象的生存期无关，一旦删除了聚合对象不一定就删除了代表部分事物的对象。组合中一旦删除了组合对 象，同时也就删除了代表部分事物的对象。
我们用浅显的例子来说明聚合和组合的区别。“国破家亡”，国灭了，家自然也没有了，“国”和“家”显然也是组合关系。而相反的，计算机和它的外设 之间就是聚合关系，因为它们之间的关系相对松散，计算机没了，外设还可以独立存在，还可以接在别的计算机上。在聚合关系中，部分可以独立于聚合而存在，部 分的所有权也可以由几个聚合来共享，比如打印机就可以在办公室内被广大同事共用
关联和聚合的区别主要在语义上，关联的两个对象之间一般是平等的，例如你是我的朋友，聚合则一般不是平等的，例如一个公司包含了很多员工，其实 现上是差不多的。聚合和组合的区别则在语义和实现上都有差别，组合的两个对象之间其生命期有很大的关联，被组合的对象是在组合对象创建的同时或者创建之后 创建，在组合对象销毁之前销毁。一般来说被组合对象不能脱离组合对象独立存在，而且也只能属于一个组合对象，例如一个文档的版本，必须依赖于文档的存在， 也只能属于一个文档。聚合则不一样，被聚合的对象可以属于多个聚合对象，例如一个员工可能可以属于多个公司。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
