OOD沉思录 --- 类和对象的关系 --- 使用关系

使用关系

对象A的方法MethodA使用了B的方法MethodB,则表示A对B存在使用关系 使用关系的最关键问题在于,A如何找到B,存在6种方案

方案一:      

A包含了B,B作为一个成员定义在A的类中,那么在MethodA中可以直接调用B.MethodB()      

如汽车可以包含车轮。      

如果汽车需要加油,那么就需要调用"加油站B.加油()"      

  1. class 汽车  
  2. {  
  3.      加油站 m_加油站;  
  4.      加油(...)  
  5.      {  
  6.       //调用某加油站的加油方法  
  7.        m_加油站.加油();  
  8.      }  
  9. }  

      那么关键问题在于,汽车如何知道加油站X?      

   如果让汽车包含加油站,肯定不合适(太土豪了,呵呵),那么还有以下5种方案:

方案二:       通过形参将加油站传递给调用的方法,那么调用形式就是“加油站.加油()",那么汽车的定义则如下

  1. class 汽车  
  2. {  
  3.      加油(加油站 X)  
  4.      {  
  5.        X.加油();  
  6.      }  
  7. }  

方案三:

      通过一个第三方类来获得加油站,如地图类,则汽车的定义如下:     

  1. class 汽车  
  2. {  
  3.      加油()  
  4.      {  
  5.        加油站 X=地图.查找一个加油站();  
  6.        X.加油();  
  7.      }  
  8. }  

方案四:      

全世界只有一个加油站,那么所有的汽车都到这里来加油,则汽车的定义如下:

  1. class 汽车  
  2. {  
  3.      加油()  
  4.      {               
  5.        加油站.TheInstance.加油();  
  6.      }  
  7. }  

      这种情况就是单件模式的例子,还记得它吗?

方案五:      

对款爷来说,随时修一个加油站,加完油就推平,这种情况在大部分领域行不通(代价太高),但是在软件领域可以(因为代价很低)

这种情况下,汽车的定义如下:

  1. class 汽车  
  2. {  
  3.      加油()  
  4.      {               
  5.        加油站 X=new 加油站();  
  6.        X.加油();  
  7.        delete X;  
  8.      }  
  9. }   

方案六:      

汽车制造商在汽车的玻璃上明确标注了,此车只能在名叫"XX加油站",则汽车的定义如下:

  1. class 汽车  
  2. {  
  3.      string 加油站名="XX加油站";  
  4.      加油()  
  5.      {               
  6.        加油站 X=企业黄页.查找(加油站名);  
  7.        X.加油();  
  8.      }  
  9. }  

      这种方案,在有的地方叫弱引用,汽车并不直接包含加油站,但是包含加油站的一个标示

posted @ 2015-10-25 21:13  赛提斯特  阅读(177)  评论(0编辑  收藏  举报