OOD沉思录 --- 类和对象的关系 --- 包含关系3

4.7 类包含的对象数目不应当超过开发者短期记忆数量,这个数目通常应该是6左右 

4.8 让系统在窄而深的包含体系中垂直分布    

假设有如下两份菜单:    

正餐　　 --->甜瓜

 　　　　--->牛排

        　 --->土豆

            --->豌豆

            --->玉米

            --->馅饼

 或者    

正餐　　--->甜瓜        

　　　　--->牛排套餐

　　　　--->牛排                    

　　　　--->配菜--->豌豆                            

　　　　　　　　--->土豆                            

　　　　　　　　--->玉米        

　　　　　　　　--->馅饼    

对使用者来说,哪种更科学呢?    

回答1或者回答2都是错的,面向对象的使用者从不关心菜单的具体实现,只关心其公共接口(价格,份量,味道等)    

那么对于实现者来说,哪种更科学呢?    

面向过程的程序员可能会选择1,因为他不希望计算正餐价格的时候出现: 价格= ...+正餐.牛排套餐.配菜.豌豆.Get价格()+正餐.牛排套餐.配菜.土豆.Get价格()+...     而更喜欢:价格=甜瓜.Get价格()+牛排.Get价格()+...+馅饼.Get价格().    

但是在面向对象的世界里,并不存在前者担忧的状况,出现他们所担忧的状况的原因只有一个原因,就是违反了经验原则   

其实这里,模式大师已经作出了最完美的解决方案,那就是组合模式.    

考虑我们现在讨论的问题都是关于的菜单上的菜肴,那么我们可以定义一个抽象的菜肴类,其中只关心价格属性

[csharp] view plaincopyprint?
  1. class 菜肴  
  2. {  
  3.      abstract double Get价格();  
  4.      virtual void Add(菜肴 para){}  
  5. }  

    那么我们可以按照套餐的定义进行各个菜肴的定义

[csharp] view plaincopyprint?
  1. class 甜瓜:菜肴  
  2.     {  
  3.           int count;//甜瓜是以个为单位计价  
  4.           readonly int 单价=10;//假设单价为常数  
  5.           double Get价格(){return 单价*count;}  
  6.     }  
  7.     class 牛排:菜肴  
  8.     {  
  9.           double weight;//牛排是以重量为单位计价  
  10.           readonly int 单价=20;//假设单价为常数  
  11.           double Get价格(){ return 单价*weight; }  
  12.     }  
  13.     class 豌豆:菜肴  
  14.     {  
  15.           double Get价格(){ return 5; }//豌豆包吃饱,5块钱  
  16.     }  
  17.     class 土豆:菜肴  
  18.     {  
  19.           double Get价格(){ return 5; }//土豆包吃饱,5块钱  
  20.     }  
  21.     class 玉米:菜肴  
  22.     {  
  23.           double Get价格(){ return 5; }//玉米包吃饱,5块钱  
  24.     }  
  25.     class 馅饼:菜肴  
  26.     {  
  27.           double piece;//馅饼按块计价  
  28.           readonly int 单价=5;//假设单价为常数  
  29.           double Get价格(){ return 单价*piece; }  
  30.     }  
  31.       

那么配菜,牛排套餐,正餐的概念呢?他们是由多份菜肴组合起来的复合体,专门针对计算价格来说,并不需要区分他们的区别,所以不需要针对每项建立一个类模型,我们只 定义一个组合菜肴类就可以满足需求:

[csharp] view plaincopyprint?
  1. class 组合菜肴:菜肴  
  2. {  
  3.      list<菜肴> lst;  
  4.      double Get价格()  
  5.      {  
  6.          double sum=0;  
  7.          foreach(菜肴 enu in lst)  
  8.              sum+=enu.Get价格();  
  9.          return sum;    
  10.      }  
  11.      override void Add(菜肴 para)  
  12.      {  
  13.           lst.Add(para);  
  14.      }  
  15. }  

    那么我们可以通过外部配置的方式建立 配菜,牛排套餐,正餐 的概念,即

[csharp] view plaincopyprint?
  1. 组合菜肴 正餐=new 组合菜肴();  
  2. 正餐.Add(new 甜瓜);  
  3. 正餐.Add(new 馅饼);  
  4.   
  5.      组合菜肴 牛排套餐=new 组合菜肴();  
  6.      牛排套餐.Add(new 牛排);  
  7.                 
  8.               组合菜肴 配菜=new 组合菜肴();  
  9.                        配菜.Add(new 豌豆);  
  10.                        配菜.Add(new 土豆);  
  11.                        配菜.Add(new 玉米);  
  12.   
  13.      牛排套餐.Add(配菜);  
  14.  正餐.Add(牛排套餐);   

顾客使用完正餐后结帐的调用很简单: 

[csharp] view plaincopyprint?
  1. 正餐.Get价格();  

 这里从头到尾都没有出现 正餐.牛排套餐.配菜.豌豆.Get价格() 形式的调用,而且将菜肴的组合需求放到了最后配置时,我们可以使用更灵活的方式配置各种套餐。     

在这里，生成组合的代码就非常灵活了，工厂模式，生成器模式等等都可以根据你的需要进行套用了

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