精华内容
下载资源
问答
  • 依赖 关联 聚合 组合

    2018-06-14 12:37:32
    介绍面向对象编程中类的四种常见关系:依赖关联聚合组合。 依赖: 依赖应该算是比较弱的一种关系,可以这样理解,当B类发生改变时会引起A类性质的改变,就称A依赖B。也就是说,A类用到了B类,可能是委托调用...
     介绍面向对象编程中类的四种常见关系:依赖,关联,聚合,组合。
     依赖:
     依赖应该算是比较弱的一种关系,可以这样理解,当B类发生改变时会引起A类性质的改变,就称A依赖B。也就是说,A类用到了B类,可能是委托调用了它的方法,或者是包含B的实例等等。
     关联:
     关联指两个类之间含有对应关系,例如一个老师对应多个学生,实现的话一般会通过在老师类中添加一个学生的集合。关联只要求存在对应关系即可,也可以是双向的,例如有许多课和许多学生,每个学生选好几门课,这时便时双向的,可以在学生类中添加课程的集合,并在课程类中添加学生的集合来表示。
     聚合:
     聚合可以理解为一种更强的关联,要求两个类是整体和部分的关系,例如车类和轮胎类。
     
     组合:
     组合也可以理解为一种更强的关联,除了要求是整体和部分的关系之外,还要求部分类不能在脱离整体类之后存活,整体类需要负责部分类的生命周期。整体类的一个对象在清除时可以将部分类对象的管理交给另一个对象或者将其清除。
     对于这四种常见关系的解读有不同的方式,这是比较广泛的版本,四种关系依次增强,耦合度也逐渐增强。
    展开全文
  • UML 依赖 关联 聚合 组合  2011-07-29 10:47:17| 分类: UML | 标签:uml  |字号大中小 订阅 依赖 依赖关系用虚线加箭头表示,如图所示: 上图表示:Animal类依赖于Water类(动物依赖...

    UML 依赖 关联 聚合 组合  

    2011-07-29 10:47:17|  分类: UML |  标签:uml   |字号 订阅

    <1>依赖

    依赖关系用虚线加箭头表示,如图所示:

      UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客

    上图表示:Animal类依赖于Water类(动物依赖于水)。

    依赖是类的五种关系中耦合最小的一种关系。因为依赖关系在生成代码的时候,这两个关系类都不会增加属性。这种微弱的关系可以用类之间的相互了解的程度来说明。(下图为代码生成图)

      UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客   UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客

    由上图可见生成的代码中Animal类的属性中没有增加Water类。那么Animal类如何使用Water类呢,有三种方式:


    依赖关系的三种表现形式:

    ① Water类是全局的,则Animal类可以调用它

    ② Water类是Animal类的某个方法中的变量,则Animal类可以调用它。代码演示如下:

      UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客

    PS:Animal有一个长大(GrownUp)方法,Water类作为该方法的变量来使用。
    请注意Water类的生命期,它是当Animal类的GrounUp方法被调用的时候,才被实例化。
    持有Water类的是Animal的一个方法而不是Animal类,这点是最重要的。

    ③ Water类是作为Animal类中某个方法的参数或者返回值时。代码演示如下

      UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客

    无用多说,Water类被Animal类的一个方法持有。生命期随着方法的执行结束而结束。

    在依赖关系中,必须采用这三种方法之一。


    <2>关联

    关联是实线加箭头表示。表示类之间的耦合度比依赖要强。

    例:水与气候是关联的,表示图如下

      UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客

    生成代码如下:

      UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客

    可见生成的代码中,Water类的属性中增加了Climate类。


    关联既有单向关联又有双向关联。

    单向关联:Water类和Climate类单向关联(如下图),则Water类称为源类,Climate类称为目标类。源类了解目标类的所有的属性和方法,但目标类并不了解源类的信息。

      UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客

    双向关联:源类和目标类相互了解彼此的信息。如将Water类和Climate类之间改为双向关联,如下图   UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客

      UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客   UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客


    依赖和关联的区别:

    ① 从类的属性是否增加的角度看:

    发生依赖关系的两个类都不会增加属性。其中的一个类作为另一个类的方法的参数或者返回值,或者是某个方法的变量而已。

    发生关联关系的两个类,其中的一个类成为另一个类的属性,而属性是一种更为紧密的耦合,更为长久的持有关系。

    ② 从关系的生命期角度看:

    依赖关系是仅当类的方法被调用时而产生,伴随着方法的结束而结束了。

    关联关系是当类实例化的时候即产生,当类销毁的时候,关系结束。相比依赖讲,关联关系的生存期更长。


    关联关系的细化

    关联关系又可以细化为聚合关系和组合关系

    聚合关系图:

      UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客

    组合关系图:

      UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客

    l 聚合和组合的区别:

    由于聚合和组合都是特殊的关联关系,在生成的代码上看不出区别,都是关联的形式。那到底这两种关系如何来区分呢。

    区分的关键有两点:

    ① 构造函数不同

    聚合关系下:雁群类(GooseGroup)和大雁类(Goose)代码如下:

      UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客

    组合关系下:大雁类(Goose)和翅膀类(Wings)代码如下:

      UML 依赖 关联 聚合 组合 - sundensky - 丁成云的博客

    这两种关系的区别在于:

    ①构造函数不同

    聚合类的构造函数中包含了另一个类作为参数。

    雁群类(GooseGroup)的构造函数中要用到大雁(Goose)作为参数传递进来。大雁类(Goose)可以脱离雁群类而独立存在。

    组合类的构造函数中包含了另一个类的实例化。

    表明大雁类在实例化之前,一定要先实例化翅膀类(Wings),这两个类紧密的耦合在一起,同生共灭。翅膀类(Wings)是不可以脱离大雁类(Goose)而独立存在

    ② 信息的封装性不同

    在聚合关系中,客户端可以同时了解雁群类和大雁类,因为他们都是独立的

    而在组合关系中,客户端只认识大雁类,根本就不知道翅膀类的存在,因为翅膀类被严密的封装在大雁类中。

    文章来自:http://blog.bandao.cn/archive/35755/blogs-679502.aspx

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

    在学习面向对象设计对象关系时,依赖、关联、聚合和组合这四种关系之间区别比较容易混淆。特别是后三种,仅仅是在语义上有所区别,所谓语义就是指上下文环境、特定情景等。他们在编程语言中的体现却是基本相同的,但是基本相同并不等于完全相同,这一点在我的前一篇博文《设计模式中类的关系》中已经有所提及,下面就来详细的论述一下在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的三个方法分别演示了依赖关系的三种不同形式。

    class Car {
    	public static void run(){
    		System.out.println("汽车在奔跑");
    	}
    }
    
    class Driver {
    	//使用形参方式发生依赖关系
    	public void drive1(Car car){
    		car.run();
    	}
    	//使用局部变量发生依赖关系
    	public void drive2(){
    		Car car = new Car();
    		car.run();
    	}
    	//使用静态变量发生依赖关系
    	public void drive3(){
    		Car.run();
    	}
    }
    
     关联关系在java中一般使用成员变量来实现,有时也用方法形参的形式实现。依然使用Driver和Car的例子,使用方法参数形式可以表示依赖关系,也可以表示关联关系,毕竟我们无法在程序中太准确的表达语义。在本例中,使用成员变量表达这个意思:车是我自己的车,我“拥有”这个车。使用方法参数表达:车不是我的,我只是个司机,别人给我什么车我就开什么车,我使用这个车。

    class Driver {
    	//使用成员变量形式实现关联
    	Car mycar;
    	public void drive(){
    		mycar.run();
    	}
    	...
    	//使用方法参数形式实现关联
    	public void drive(Car car){
    		car.run();
    	}
    }
    
    聚合关系是是一种比较强的关联关系,java中一般使用成员变量形式实现。对象之间存在着整体与部分的关系。例如上例中

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

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

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

    	public Driver(Car car){
    		mycar = car;
    	}
    
    所以,关联、聚合、组合只能配合语义,结合上下文才能够判断出来,而只给出一段代码让我们判断是关联,聚合,还是组合关系,则是无法判断的。





    展开全文
  • UML 为我们定义了它们之间的关系,就是:依赖关联聚合组合还有泛化。  泛化关系比较好理解,就是表示类之间的继承关系。容易混淆的是依赖关联聚合组合的关系。这里做一些甄别:

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

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

           1、  依赖和关联的颠倒

           在网上查找了一下依赖和关联的区别,有说“ 关联本身即是一种依赖”,亦有说“ 依赖是一种弱关联 ”,其实说来说去是一档子事。依赖和关联都是说一个类用到了另一个类。其区别在于一个是使用,一个是拥有。

          依赖 :具有某种偶然性。比如说我要过河,没有桥怎么办,我就去借来一条小船渡过去。我与小船的关系仅仅是使用(借用)的关系。表现在代码上,为依赖的类的某个方法以被依赖的类作为其参数。或者是 class A 的某个方法创造了 class B 的实例抑或对 class B 的 静态方法的调用 。如果 A 依赖于 B ,那意味着 B 的变化可能要求 A 也发生变化;

    有两个元素A、B,如果元素A的变化会引起元素B的变化,则称元素B依赖(Dependency)于元素A。在UML中,使用带箭头的虚线表示依赖关系。

    在类中,依赖关系有多种表现形式,如:一个类向另一个类发消息;一个类是另一个类的成员;一个类是另一个类的某个操作参数等等。

           这是 uml 图表示的依赖关系:

     

    代码表现:

    public class Person
    {
    	//划船
    	public void oarage (Boat boat)
    	{
    		boat.oarage();     
    	}    
    } 

    关联:有名的客户和订单的关系以及公司和员工的关系,都是关联关系。还有就是我和我的单车的例子,他们都是一种“拥有”的关系。表现在代码上,就是一个类包含另一个类的实例, 通常表现为被关联类以类属性的形式出现在关联类的类定义中,也可以表现为关联类引用了一个类型为被关联类的全局变量。关联可以使单向的,也可以使双向的。

     关联(Association)表示连个类的实例之间存在的某种语义上的联系。例如,一个老师为某个学校工作,一个学校有多间教室。我们就认为教室和学校、学校和教室之间存在着关联关系。

    关联关系为类之间的通信提供了一种方式,它是所有关系中最通用、语义最弱的。

    从网上找到的公司和员工的UML 图和代码 :

     

    公司和员工的关联关系

    public class Company
    {
    	private Employee employee;
    	public Employee getEmployee()
    	{
    		return employee; 
    	}
    	public void setEmployee(Employee employee)
    	{
    		this.employee=employee; 
    	}
    	//公司运作        
    	public void run()
    	{
    		employee.startWorking();
    	}
    }


     

          可见依赖于与关联亦有动静之别, 关联的类“ 静态” 地引用了被关联类的实例变量,而依赖的偶然性也正说明了它的动态性。

    2、  聚合与组合同出而异体

          聚合与组合其实都是关联的特例,都是整体和部分的关系。他们的区别在于聚合的两个对象之间是可分离的,他们具有各自的生命周期。而组合往往表现为一种唇齿相依的关系。

    聚合:一种容纳或曰包含的关系,如同机场和飞机,汽车和轮胎的关系。其实仔细想想,前面的公司和员工的关系也有聚合的味道在里面。 如一个电话机包含一个话筒,一台计算机包含显示器、键盘和主机等都是聚合关系的例子。在UML中,聚合关系用一个带空心菱形的实线表示,空心菱形指向的是代表“整体”的类。

    组合:也可称之为强聚合,整体和部分是不可分的,整体的生命周期结束时也就是部分的生命周期到头时。很有名的就是桌子和桌子腿的关系。 如果聚合关系中的表示“部分”的类的存在,与表示“整体”的类有着紧密的关系,例如“公司”与“部门”之间的关系,那么就应该使用“组合”关系来表示。在UML中,组合关系是用带有实心菱形的实线表示

                    聚合的 UML 图 :

     

     

    组合的 UML 图:

     

    然而,聚合与组合的代码表现形式是一样的,都可以表现为以下的形式,它们仅仅具有语义上的区别。

    网上找到的电脑和 CPU 的关系的代码表现:

    public class Computer
    {
    	private CPU cpu; 
    	public CPU getCPU()
    	{
    		return cpu; 
    	}
    	public void setCPU(CPU cpu)
    	{
    		this.cpu=cpu; 
    	}       
    	//开启电脑     
    	public void start()
    	{
    		//cpu运作  
    		cpu.run();
    	}
    }


     

    泛化关系 

            泛化关系描述了一般事物与该事物中的特殊种类之间的关系,也就是父类与子类之间的关系。继承关系是泛化关系的反关系,也就是说子类是从父类中继承的,而父类则是子类的泛化。在UML中,使用带空心箭头的实线表示,箭头指向父类。

            在UML中,对泛化关系有三个要求:

    1>子类应与父类完全一致,父类所具有的关联、属性和操作,子元素都应具有。

    2>子类中除了与父类一致的信息外,还包括额外的信息。

    3>可以使用子父类实例的地方,也可以使用子类实例。

    例如:“书籍”与“非计算机类书籍”就是泛化关系,箭头指向父类"书籍"。

     

    这一篇讲的也不错:http://www.cppblog.com/mzty/archive/2008/04/16/47264.html

    结语:

          一般情况下,当某个类被当作参数传递并且被当作结果返回的时候,或者被当作某个方法内的临时变量使用的时候 , 可以运用依赖关系,使用关联来表示一个拥有关系,而不是整体 - 部分关系。使用聚合来表示一个动态的整体 - 部分关系,而是用组合来表示一个静态的整体 - 部分关系。但是需要指出的是,所谓“关系”只是在某个问题域才有效,离开了这个问题域,可能这些关系就不成立了,例如之前我和小船的关系,可能在某个问题域中,我是船夫,我的工作就是驾着小船在河上摆渡,那我和小船的关系就上升为关联关系了。试想一下,武侠小说中的那些剑仙们,修炼到人剑合一的境地,剑在人在,剑亡人亡,那它们之间的关系就似乎与组合关系类似了。又如在关心汽车的领域里,轮胎是一定要组合在汽车类中的,因为它离开了汽车就没有意义了。但是在卖轮胎的店铺业务里,就算轮胎离开了汽车,它也是有意义的,这就可以用聚合了。这说明关系是在特定的问题域中的“关系”,会随着问题域的迁移而改变的。

    展开全文
  • UML中几种类间关系:继承、实现、依赖关联聚合组合的联系与区别
  • 比如菱形、圆形和方形都是形状的一种,那么他们都应该从形状类继承而不是聚合。 如果你确定两件对象之间是has-a的关系,那么此时你应该使用聚合;比如电脑是由显示器、CPU、硬盘等组成的,那么你应该把显示器、CPU...
  • 【软考】--UML 依赖 关联 聚合 组合

    千次阅读 热门讨论 2014-10-12 17:06:39
     上图表示:Animal类依赖于Water类(动物依赖于水)。  依赖是类的五种关系中耦合最小的一种关系。因为依赖关系在生成代码的时候,这两个关系类都不会增加属性。这种微弱的关系可以用类之间的相互了解的程度来说明...
  • UML中依赖泛化关联实现聚合组合的C#实现UML中依赖泛化关联实现聚合组合的C#实现
  • UML中依赖泛化关联实现聚合组合的Java实现
  • 继承 实现 依赖 关联 聚合 组合
  • 依赖关联聚合组合之间区别

    千次阅读 2019-06-06 00:11:32
    依赖关联聚合组合之间区别 耦合度依次增强:依赖关联聚合组合 1、依赖(Dependency)关系 依赖关系表示一个类依赖于另一个类的定义。依赖关系中,可以简单的理解,就是一个类A使用到了另一个类B,而这种...
  • 在学习面向对象设计时,类关系涉及依赖关联聚合组合和泛化这五种关系,耦合性依次递增。关于耦合度,可以简单地理解为当一个类发生变更时,对其他类造成的影响程度,影响越小则耦合度越弱,影响越大耦合度越强...
  • UML图 依赖关联聚合组合

    千次阅读 2014-05-10 21:08:44
    UML图 依赖关联聚合组合
  • UML 本身是一套符号的规定,就像数学符号和化学符号一样,这些符号用于描述软件模型中的各个元素和他们之间的关系,比如类、接口、实现、泛化、依赖组合聚合等,如下图: 使用工具 AmaterasUML(自己去网上找...
  • 关于面向对象的依赖关联聚合组合关系
  • 关联聚合组合需要根据上下文语义来定义。 首先看一看书上对这四种关系的定义: 依赖(Dependency)关系是类与类之间的联接。依赖关系表示一个类依赖于另一个类的定义。一般而言,依赖关系在Java语言中体现为...
  • 主要介绍了Java依赖-关联-聚合-组合之间区别理解,依赖关系比较好区分,它是耦合度最弱的一种,下文给大家介绍的非常详细,感兴趣的朋友一起看看吧
  • UML学习之依赖_关联_聚合_组合_继承
  • UML关系(泛化,实现,依赖,关联(聚合,组合)) 博客分类:  DesignPattern 设计模式UML关系泛化 实现 依赖 关联 聚合 组合    UML的构造快包含3种:  (1) 事物(4种):结构事物,行为事物,...
  • 组合关系:又称复合,合成关系,也是关联关系的一种特例,是一种contains-a的关系,强的“拥有”关系,这种关系比聚合更强,强聚合; 他同样体现整体与部分间的关系,但此时整体与部分是不可分的,整体的生命周期...
  • UML中依赖泛化关联实现聚合组合的C#实现_配UML图.doc
  • UML类关系-依赖,关联,聚合组合 这几种关系很容易混淆,一个总结文档。
  • 泛化、依赖关联聚合组合

    千次阅读 2014-08-26 16:28:05
    时间久了不用了,慢慢慢慢也就淡忘了,写一盘...类的关系一般分为泛化(继承,实现),依赖关联聚合组合 泛化 可以看出是Tiger属于Animal,是Animal的一实现。 箭头的意思是Tiger/Dog是Animal的一个泛化 继承
  • 继承实现依赖关联聚合组合 目录(?)[+] 继承、实现、依赖、关联、聚合、组合的联系与区别 分别介绍这几种关系: 继承 指的是一个类(称为子类、子接口)继承另外的一个类(称为父类、...
  • 文章目录 UML类关系 1. 泛化关系 2. 实现关系 3. 依赖关系 4. 关联关系 5. 聚合关系 6. 组合关系 7. 耦合度强弱 ...对于面向对象编程语言,UML中所说的泛化关系...依赖关系<关联关系<聚合关系<组合关系
  • Java 对象间关系(依赖关联聚合组合

    千次阅读 多人点赞 2018-09-11 23:53:41
    面向对象设计对象间关系:依赖关联聚合组合,四种关系容易混淆。特别后三种,只是在语义上有所区别,所谓语义就是指上下文环境、特定情景等。 1、依赖(Dependency) 依赖关系,是类与类之间的联接。依赖关系...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,167
精华内容 17,266
关键字:

依赖关联聚合组合