类之间的关系有五种:继承、依赖、关联、聚合、组合.在UML绘制图的过程中我们也要使用这五种关系图.
*1
、关
联
Association
关联指的是类之间的引用关系。这是实体域对象之间最普遍使用最广泛的一种关系。关联可分为一对一、一对多和多对多关联
案例:
Customer(
客户
)
对象与
Orders(
订单
)
对象之间就存在着一对多的关联关系
,
一个
Customer(
客户
)
可以有多个
Orders(
订单
),
而一个
Orders(
订单
)
只能属于一个
Customer(
客户
)
。显然客户与订单之间存在着一对多的关系
,
反之订单与客户之间存在着多对一的关系。
那么对于
java
中的类到底怎么实现一对多与多对一得关联呢
?
答
:
如果类
Customer
与
Orders
关联
,
那么第一种方式:在
Customers(
客户
)
类中定义集合
Orders(
订单
)
类的对象作为
Customer(
客户
)
类的一个属性
.
这样就解决了
Customer
类与
Orders
类之间的一对多的关系了
.
具体的代码如下:
package
redarmy_chen.edu;
import
java.util.HashSet;
import
java.util.Set;
public
class
Customer {
/**
客户的
ID */
private
int
id
;
/**
客户的名称
*/
private
String
name
;
/**
客户的邮箱
*/
private
String
email
;
/**
所有与客户
Customer
对象关联的
Order
对象
*/
private
Set<Orders> allOrders = new HashSet<Orders>();
/**
默认的构造器
*/
public
Customer() {
}
/**
完整的构造器
*/
public
Customer(
int
id, String name, String email, Set<Orders> allOrders) {
this
.
id
= id;
this
.
name
= name;
this
.
email
= email;
this
.
allOrders
= allOrders;
}
/**
下面是对应私有属性的
set get
方法
*/
public
int
getId() {
return
id
;
}
public
void
setId(
int
id) {
this
.
id
= id;
}
public
String getName() {
return
name
;
}
public
void
setName(String name) {
this
.
name
= name;
}
public
String getEmail() {
return
email
;
}
public
void
setEmail(String email) {
this
.
email
= email;
}
public
Set<Orders> getAllOrders() {
return
allOrders
;
}
public
void
setAllOrders(Set<Orders> allOrders) {
this
.
allOrders
= allOrders;
}
}
以上就构成了
Customer
类到
Orders
类的一对多关联。关联的
EA
图如图
1.1
所示:
![](http://student.csdn.net/attachment/201012/8/1394199_1291776412rORR.jpg)
图
1.1
同样也可以建立从
Orders
类到
Customer
类的关联
,
一个
Orders
类的对象只能对应一个
Customer
的对象
,
因此在
Orders
类中定义一个
Customer
对象
,
来存放该订单属于哪个客户。这样就可实现
java
类中的多对一的关系了
.
具体代码如下:
package
redarmy_chen.edu;
public
class
Orders {
/** Orders
订单对象的序号
ID */
private
int
id
;
/** Orders
订单对象的编号
*/
private
String
orderNumber
;
/** Orders
订单对象的价格
*/
private
double
price
;
/**
与
Orders
对象关联的
Customer
对象
*/
private
Customer
customer
;
public
Orders() {
}
public
Orders(
int
id, String orderNumber,
double
price, Customer customer) {
this
.
id
= id;
this
.
orderNumber
= orderNumber;
this
.
price
= price;
this
.
customer
= customer;
}
/**
下面是对应私有属性的
set get
方法
*/
public
int
getId() {
return
id
;
}
public
void
setId(
int
id) {
this
.
id
= id;
}
public
String getOrderNumber() {
return
orderNumber
;
}
public
void
setOrderNumber(String orderNumber) {
this
.
orderNumber
= orderNumber;
}
public
double
getPrice() {
return
price
;
}
public
void
setPrice(
double
price) {
this
.
price
= price;
}
public
Customer getCustomer() {
return
customer
;
}
public
void
setCustomer(Customer customer) {
this
.
customer
= customer;
}
}
以上就构成了
Orders
类到
Customer
类的多对一的关联。关联的
EA
图如
1.2
图所示:
![](http://student.csdn.net/attachment/201012/8/1394199_1291776414UqzK.jpg)
图
1.2
同过以上的讲解我们又可以把关联分为单向关联和双向关联
a、
单向关联:仅仅建立从
Customer
到
Orders
的一对多的关联
,
即仅仅在
Customer
类中定义
allOrders
集合
,
或者仅仅建立从
Orders
到
Customer
的多对一的关联
,
即仅仅在
Orders
类中定义
customer
属性
(
参考以上两个图的结果
)
。
b、
双向关联
:
即建立从
Customer
到
Orders
的一对多的关联
,
又建立从
Orders
到
Customer
的多对一的关联。如图
1.3
所示:
![](http://student.csdn.net/attachment/201012/8/1394199_1291776416LNcI.jpg)
图
1.3
*2
、
依赖
Dependency
依赖指的是类之间的访问关系
。如果类
A
访问类
B
的属性或方法,或者类
A
负责实例化类
B,
那么可以说类
A
依赖类
B
和关联关系不同,无需把类
B
定义为类
A
的属性
案例
1
:在原有的
Customer
类的基础之上
,
我们再创建一个
CustomerOper
的类
,
此类完成向数据库表中插入一条
Customer(
客户
)
记录
.
代码如下:
package
redarmy_chen.edu;
public
class
CustomerOper {
/**
在此方法中我们使用到
Customer
类对象
并使用此对象的属性
或者方法
*/
public
boolean
insert(Customer customer){
/**
在此方法中省略了插入数据库实现的方法
,
如果学员有兴趣可以自己实现
*/
return
false
;
}
}
以上就构成了
CustomerOper
类到
Customer
类的依赖关系。依赖的
EA
图如
1.4
图所示:
![](http://student.csdn.net/attachment/201012/8/1394199_12917764171T31.jpg)
图1.4
案例
2
:在原有的
Customer
类的基础
,
创建
CreateCustomer
类
,
此类负责创建一个
Customer
类的实例
.
代码如下:
package
redarmy_chen.edu;
public
class
CreateCustomer {
/**
在此负责创建一个
Customer
的实例并返回
*/
public
Customer loadCustomer(){
/**
具体实现方法省略
*/
return
null
;
}
}
以上就构成了
CustomerCreate
类到
Customer
类的依赖关系。依赖的
EA
图如
1.5
图所示:
![](http://student.csdn.net/attachment/201012/8/1394199_129177642222bY.jpg)
此外
,
软件应用中上层的类总是依赖下层的类或接口
.
比如在业务逻辑层的类依赖持久化层的类或接口。
总结:谁使用了谁
,
谁负责创建谁
=
è
谁就依赖谁。
*3
、
聚合
Aggregation 聚集是关联关系的一种特例
聚集指的是整体与部分之间的关系
他体现的是整体与部分、拥有的关系,即
has-a
的关系,此时整体与部分之间是可分离的,他们可以具有各自的生命周期,部分可以属于多个整体对象,也可以为多个整体对象共享;比如计算机与
CPU
、公司与员工的关系等;表现在代码层面,和关联关系是一致的,只能从语义级别来区分;例如:人与手就是聚集关系
.
由于聚集关系比较简单
,
通过图
1.6
所示:
![](http://student.csdn.net/attachment/201012/8/1394199_1291776426s8IX.jpg)
*4
、
组合也是关联关系的一种特例,他体现的是一种
contains-a
的关系,这种关系比聚合更强,也称为强聚合;他同样体现整体与部分间的关系,但此时整体与部分是不可分的,整体的生命周期结束也就意味着部分的生命周期结束;比如你和你的大脑;表现在代码层面,和关联关系是一致的,只能从语义级别来区分;如图
1.7
所示
![](http://student.csdn.net/attachment/201012/8/1394199_1291776426Q6gF.jpg)
*5
、一
般化
Generalization
一般化值得是类之间的继承关系
在学习面向对象的时候老师都会重点讲解:下面给出
EA
图的绘制方法如图
1.8
所示
![](http://student.csdn.net/attachment/201012/8/1394199_1291776430l3jS.jpg)