设计模式中类的关系

在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. public class Father{
  9. Son son = new Son();
  10. public void giveGift(){
  11. System.out.println(“送给”+son.getName()+“礼物”);
  12. }
  13. }

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. public void driver(){
  12. System.out.println(“车的型号:”+car.getType());
  13. }
  14. public void sleep(){
  15. System.out.println(“我在房子里睡觉:”+house.getAddress());
  16. }
  17. }

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. Public void study(){
  10. System.out.println(“学习要用灵魂”+soul.getName());
  11. }
  12. Public void eat(){
  13. System.out.println(“吃饭用身体:”+body.getName());
  14. }
  15. }

5.继承(Generalization)

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

6.实现(Implementation)

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

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

原文请访问:设计模式中类的关系 - 卡奴达摩的专栏 - 博客频道 - CSDN.NET

时间: 2024-11-07 12:02:35

设计模式中类的关系的相关文章

[转]设计模式中类的关系

转自 http://blog.csdn.net/zhengzhb/article/details/7187278 在java以及其他的面向对象设计模式中,类与类之间主要有6种关系,他们分别是:依赖.关联.聚合.组合.继承.实现.他们的耦合度依次增强. 1. 依赖(Dependence)  依赖关系的定义为:对于两个相对独立的对象,当一个对象负责构造另一个对象的实例,或者依赖另一个对象的服务时,这两个对象之间主要体现为依赖关系.定义比较晦涩难懂,但在java中的表现还是比较直观的:类A当中使用了类

设计模式中类的关系-类别总结

在java以及其他的面向对象设计模式中,类与类之间主要有6种关系,他们分别是:依赖.关联.聚合.组合.继承.实现.他们的耦合度依次增强. 1. 依赖(Dependence)  依赖关系的定义为:对于两个相对独立的对象,当一个对象负责构造另一个对象的实例,或者依赖另一个对象的服务时,这两个对象之间主要体现为依赖关系.定义比较晦涩难懂,但在java中的表现还是比较直观的:类A当中使用了类B,其中类B是作为类A的方法参数.方法中的局部变量.或者静态方法调用.类上面的图例中:People类依赖于Book

设计模式中的关系在代码中的实现

我们都学过UNL,其中类图中有6类关系:泛华(继承).实现.关联.组合.聚合.依赖.由于他们之间也存在各种联系,我就将他们分为了4大类:依赖.关联.继承.实现. 整理如图: 从这个图中,我们就可以看出我是如何划分的了:聚合和组合是关联的特殊形式,所以就这样划分了. 我们知道,这6个关系的耦合的耦合度:继承=实现<依赖<关联<聚合<组合. 那么下一步,我们就看看,他们在设计模式的代码中是怎样实现的. 1.依赖关系 依赖关系的定义很绕口,其实说白了就是:一个对象依赖于另一个对象的服务.

设计模式奠基石——UML关系转化为代码

1.继承关系(泛化关系) [说明]:继承关系是子类(派生类)继承父类(基类),或者子接口继承父接口的关系.即子类对象"is a" 父类对象,比方鸟是动物. [UML图]: 图解:Animal为父类,Bird类.Fish类.Dog类分别继承了Animal类,它们不仅继承了Animal的公用方法Breath(),同一时候也依据自己的实际须要拓展了相关方法(Fly()方法.Swim()方法.Run()方法). [相应代码]: //Animal类(父类): class Animal { pub

设计模式间的关系

从七月份开始一直到九月底才看完设计模式,在这个过程中我不敢说我已经掌握了那本书里面的内容,或者说1/5,没能力说也没有资格说.但是结果不重要,重要的是这个过程我的收获!主要包括如下几个方面: 1.认识了这么多设计模式.刚刚接触java没多久就在学长那里听过设计模式的大名,但是由于能力有限,一直不敢触碰.而今有幸将其都认识了. 2.开始有设计的理论了.在接触设计模式之前没有怎么想过设计方面东东,看到问题就立马动手解决,没有想到怎么样来设计更好,如何来是这块更加优化.漂亮. 3.开始考虑系统的可扩展

架构、框架、设计模式之间的关系简述

http://developer.51cto.com/art/200906/130816.htm 一.软件体系结构和框架的定义 软件体系结构的英文单词是"architecture". Architecture的基本词义是建筑.建筑学.建筑风格. 软件体系结构虽然根植于软件工程,但还处于一个研究发展的阶段,迄今为止还没有一个为大家所公认的定义. <设计模式>中对框架的定义是框架就是一组相互协作的类,对于特定的一类软件,框架构成了一种可重用的设计. 软件框架是项目软件开发过程中

设计模式中类之间的关系

面向对象设计模式中,类与类之间主要有6种关系,他们分别是:依赖.关联.聚合.组合.继承.实现.他们的耦合度依次增强. 1.依赖(Dependence) 描述: 可以简单的理解,就是一个类A使用到了另一个类B,而这种使用关系是具有偶然性的.临时性的.非常弱的,但是B类的变化会影响到A.表现在代码层面,类A当中使用了类B,其中类B是作为类A的方法参数.方法中的局部变量.或者静态方法调用.注意,要避免双向依赖.一般来说,不应该存在双向依赖. 1 //book.h 2 class Book 3 {} 4

设计模式中的关系

设计模式中,主要有以下一些关系: 实现,通常是继承自基类: uml中的是使用 空心的虚线箭头. 泛化,是一种实现,在代码中表现为继承自非基类.uml 中使用 空心的实线箭头. 组合, 是一种强依赖关系,比如汽车是由一些零件组合而来的.uml中使用 实心的实线箭头. 聚合关系,是一种弱依赖,员工组成部门,部门没有了,员工还在. uml 中使用空心的实线箭头. 关联关系,是人为赋予的关系.uml中是用实线表示的,不强调箭头的方向. 依赖, 是一个对象,在运行期间,会用到另一个对象.uml 带箭头的虚

Java中类的关系

在java里类的关系大致分为三种, 1.继承(a is b):继承extends,实现implement 2.包含(a has b):组合>聚合>关联.关系亲密度越来越小,一个类在另一个类中声明为属性. 3.依赖(a use b):一个类中用到了别的类对象,比如a类的方法中创建b的对象并使用其属性跟方法. 类的关系设计原则:高内聚,低耦合(继承>组合>聚合>关联>依赖) 高内聚:尽可能类的每个成员方法只完成一件事(最大限度的聚合) 低耦合:减少类内部,一个成员方法调用另