场景分析
我们平时去餐厅吃饭，都会使用菜单来点餐，今天我们来实现一个超级菜单，这个一个菜单大集合，包括单一菜品和子菜单，如图所示：
可以看到上面的菜单不但包括单个的菜品项目，还包括子菜单项目，子菜单也包含一系列菜品或者子菜单。
我们现在想实现两个个需求：
- 如果是菜单项目，我们需要打印菜单的名称和描述，添加删除子菜单或者菜品，打印所有子菜单、子菜单包括的菜品、子菜单的子菜单的名称和描述，一直递归打印到最后一个菜品项目。
- 如果是菜品项目，我们需要得到菜品的价格、描述、名称、是否是素菜这些信息
可以发现上述两个需求有相同和不同的地方，常规做法就是区别对待两者各自进行操作。但是这样以后扩展起来就非常麻烦，如果添加或者删除两者，那么原有代码就需要做相应的修改。而且两者其实很多操作都是类似的，却要写两套代码，操作繁琐。
分析下上面的图，我们不难发现这是一个典型的树形结构图，菜品项目是叶节点，子菜单项目是子节点（子节点还可以包含子节点或者叶节点），所有菜单是根节点，这个结构可以无限延伸下去。
如果我们能统一对待叶节点和子节点，使用一致的方式在树结构间游走处理，那就方便许多，这样不管以后新加一个叶节点还是子节点，原有代码都不需要修改，因为他们二者的处理方式完全一致。
下面我们就来看看具体的实现。
代码实现
1、定义叶节点和子节点的父类
先定义一个抽象类，作为叶节点和子节点的父类，父类定义了两者的所有操作方法，两者可以自己选择实现自己需要的方法。父类的每个方法默认实现都是抛出异常，等待子类覆盖实现。如果子类没有覆盖，然后又调用了该方法，就会抛出异常。
#import <Foundation/Foundation.h>
@interface MenuComponent : NSObject
-(void)add:(MenuComponent *)component;
-(void)remove:(MenuComponent *)component;
-(MenuComponent*)getChild:(NSInteger)position;
-(NSString*)getName;
-(NSString*)getDescription;
-(CGFloat)getPrice;
-(BOOL)isVegetarian;
-(void)print;
@end
===============
#import "MenuComponent.h"
@implementation MenuComponent
-(void)add:(MenuComponent *)component{
NSString *reason = [NSString stringWithFormat:@"【%@】没有实现该方法",NSStringFromClass([self class])];
@throw ([NSException exceptionWithName:@"不支持该方法" reason:reason userInfo:nil]);
}
-(void)remove:(MenuComponent *)component{
NSString *reason = [NSString stringWithFormat:@"【%@】没有实现该方法",NSStringFromClass([self class])];
@throw ([NSException exceptionWithName:@"不支持该方法" reason:reason userInfo:nil]);
}
-(MenuComponent *)getChild:(NSInteger)position{
NSString *reason = [NSString stringWithFormat:@"【%@】没有实现该方法",NSStringFromClass([self class])];
@throw ([NSException exceptionWithName:@"不支持该方法" reason:reason userInfo:nil]);
}
-(NSString *)getName{
NSString *reason = [NSString stringWithFormat:@"【%@】没有实现该方法",NSStringFromClass([self class])];
@throw ([NSException exceptionWithName:@"不支持该方法" reason:reason userInfo:nil]);
}
-(NSString *)getDescription{
NSString *reason = [NSString stringWithFormat:@"【%@】没有实现该方法",NSStringFromClass([self class])];
@throw ([NSException exceptionWithName:@"不支持该方法" reason:reason userInfo:nil]);
}
-(CGFloat)getPrice{
NSString *reason = [NSString stringWithFormat:@"【%@】没有实现该方法",NSStringFromClass([self class])];
@throw ([NSException exceptionWithName:@"不支持该方法" reason:reason userInfo:nil]);
}
-(BOOL)isVegetarian{
NSString *reason = [NSString stringWithFormat:@"【%@】没有实现该方法",NSStringFromClass([self class])];
@throw ([NSException exceptionWithName:@"不支持该方法" reason:reason userInfo:nil]);
}
-(void)print{
NSString *reason = [NSString stringWithFormat:@"%@没有实现该方法",NSStringFromClass([self class])];
@throw ([NSException exceptionWithName:@"不支持该方法" reason:reason userInfo:nil]);
}
@end
2、实现菜单项目
#import "MenuComponent.h"
@interface Menu : MenuComponent
@property(copy ,nonatomic)NSString *name;
@property(copy ,nonatomic)NSString *desc;
@property(strong,nonatomic)NSMutableArray<MenuComponent *>* menuComponentArr;
-(instancetype)initMenuItemWithName:(NSString*)name withDesc:(NSString*)desc;
@end
========================================
#import "Menu.h"
@implementation Menu
-(instancetype)initMenuItemWithName:(NSString *)name withDesc:(NSString *)desc{
if (self == [super init]) {
self.name = name;
self.desc = desc;
self.menuComponentArr = [NSMutableArray array];
}
return self;
}
-(NSString *)getDescription{
return self.desc;
}
-(NSString *)getName{
return self.name;
}
-(void)add:(MenuComponent *)component{
[self.menuComponentArr addObject:component];
}
-(void)remove:(MenuComponent *)component{
[self.menuComponentArr enumerateObjectsUsingBlock:^(MenuComponent * _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
if(obj == component){
[self.menuComponentArr removeObject:component];
}else{
if ([obj isKindOfClass:[Menu class]]) {
if ([((Menu *)obj).menuComponentArr containsObject:component]) {
[obj remove:component];
}
}
}
}];
}
-(MenuComponent*)getChild:(NSInteger)position{
return self.menuComponentArr[position];
}
-(void)print{
NSLog(@"菜单名称：%@ | 菜单描述：%@ " ,self.name, self.desc);
if(self.menuComponentArr.count){
for (MenuComponent * component in self.menuComponentArr) {
[component print];
}
}
}
@end
3、实现菜品项目
#import "MenuComponent.h"
@interface menuItem : MenuComponent
@property(copy ,nonatomic)NSString *name;
@property(copy ,nonatomic)NSString *desc;
@property(assign,nonatomic)NSInteger isVegetarain;
@property(assign,nonatomic)CGFloat price;
-(instancetype)initMenuItemWithName:(NSString*)name withDesc:(NSString*)desc withVegetarain:(NSInteger)isVege withPrice:(CGFloat)price;
@end
=====================================================
#import "menuItem.h"
@implementation menuItem
-(instancetype)initMenuItemWithName:(NSString *)name withDesc:(NSString *)desc withVegetarain:(NSInteger)isVege withPrice:(CGFloat)price{
if (self == [super init]) {
self.name = name;
self.desc = desc;
_isVegetarain = isVege;
self.price = price;
}
return self;
}
-(CGFloat)getPrice{
return self.price;
}
-(NSString *)getDescription{
return self.desc;
}
-(NSString *)getName{
return self.name;
}
-(BOOL)isIsVegetarain{
return self.isVegetarain;
}
-(void)print{
NSLog(@"菜品名称：%@ | 菜品价格：%f | 菜品描述：%@ | 是否是素菜：%@" ,self.name, self.price, self.desc, self.isVegetarain ? @"是":@"不是");
}
@end
4、客户端调试
我们先按照文章开头的图完成菜单的构建
MenuComponent *pancakeHouseMenu = [[Menu alloc]initMenuItemWithName:@"博饼屋菜单" withDesc:@"早餐"];
MenuComponent *dinnerMenu = [[Menu alloc]initMenuItemWithName:@"正餐菜单" withDesc:@"午餐"];
MenuComponent *cafeMenu = [[Menu alloc]initMenuItemWithName:@"咖啡菜单" withDesc:@"晚餐"];
MenuComponent *dessertMenu = [[Menu alloc]initMenuItemWithName:@"甜点菜单" withDesc:@"饭后甜点"];
MenuComponent *allMenu = [[Menu alloc]initMenuItemWithName:@"所有菜单" withDesc:@"所有菜单的组合"];
[allMenu add:pancakeHouseMenu];
[allMenu add:dinnerMenu];
[allMenu add:cafeMenu];
menuItem *meatItem = [[menuItem alloc]initMenuItemWithName:@"红烧肉" withDesc:@"祖传红烧肉，肥而不腻" withVegetarain:0 withPrice:177.2f];
menuItem *fishItem = [[menuItem alloc]initMenuItemWithName:@"清蒸鲈鱼" withDesc:@"新鲜味美，回味无穷" withVegetarain:0 withPrice:2332.0f];
[dinnerMenu add:meatItem];
[dinnerMenu add:fishItem];
menuItem *dessertItem1 = [[menuItem alloc]initMenuItemWithName:@"清炒小白菜" withDesc:@"味美而鲜，有机绿色无污染" withVegetarain:1 withPrice:17.3f];
menuItem *dessertItem2 = [[menuItem alloc]initMenuItemWithName:@"玉米排骨汤" withDesc:@"饭后一口汤，快乐似神仙" withVegetarain:1 withPrice:243.3f];
[dessertMenu add:dessertItem1];
[dessertMenu add:dessertItem2];
[dinnerMenu add:dessertMenu];
此时我们打印一下所有菜单，只需要一句命令就可以打印出所有的菜品项目和子菜单项目
[allMenu print];
输出如下：
2016-12-04 19:22:12.569 组合模式[39987:657657] 菜单名称：所有菜单 | 菜单描述：所有菜单的组合
2016-12-04 19:22:12.570 组合模式[39987:657657] 菜单名称：博饼屋菜单 | 菜单描述：早餐
2016-12-04 19:22:12.570 组合模式[39987:657657] 菜单名称：正餐菜单 | 菜单描述：午餐
2016-12-04 19:22:12.570 组合模式[39987:657657] 菜品名称：红烧肉 | 菜品价格：177.199997 | 菜品描述：祖传红烧肉，肥而不腻 | 是否是素菜：不是
2016-12-04 19:22:12.570 组合模式[39987:657657] 菜品名称：清蒸鲈鱼 | 菜品价格：2332.000000 | 菜品描述：新鲜味美，回味无穷 | 是否是素菜：不是
2016-12-04 19:22:12.570 组合模式[39987:657657] 菜单名称：甜点菜单 | 菜单描述：饭后甜点
2016-12-04 19:22:12.571 组合模式[39987:657657] 菜品名称：清炒小白菜 | 菜品价格：17.299999 | 菜品描述：味美而鲜，有机绿色无污染 | 是否是素菜：是
2016-12-04 19:22:12.571 组合模式[39987:657657] 菜品名称：玉米排骨汤 | 菜品价格：243.300003 | 菜品描述：饭后一口汤，快乐似神仙 | 是否是素菜：是
2016-12-04 19:22:12.571 组合模式[39987:657657] 菜单名称：咖啡菜单 | 菜单描述：晚餐
此时我们试着删除dessertMenu，然后再次打印菜单
2016-12-04 19:22:12.571 组合模式[39987:657657] 菜单名称：所有菜单 | 菜单描述：所有菜单的组合
2016-12-04 19:22:12.571 组合模式[39987:657657] 菜单名称：博饼屋菜单 | 菜单描述：早餐
2016-12-04 19:22:12.571 组合模式[39987:657657] 菜单名称：正餐菜单 | 菜单描述：午餐
2016-12-04 19:22:12.571 组合模式[39987:657657] 菜品名称：红烧肉 | 菜品价格：177.199997 | 菜品描述：祖传红烧肉，肥而不腻 | 是否是素菜：不是
2016-12-04 19:22:12.571 组合模式[39987:657657] 菜品名称：清蒸鲈鱼 | 菜品价格：2332.000000 | 菜品描述：新鲜味美，回味无穷 | 是否是素菜：不是
2016-12-04 19:22:12.571 组合模式[39987:657657] 菜单名称：咖啡菜单 | 菜单描述：晚餐
可以看到移除成功。
如果我们试着对dinnerMenu这个子菜单项目调用如下方法
[dinnerMenu isVegetarian];
会发现直接崩溃报错如下：
2016-12-04 20:40:44.049 组合模式[40371:710191] *** Terminating app due to uncaught exception '不支持该方法', reason: '【Menu】没有实现该方法'
此处就涉及到一个取舍问题：透明性和安全性谁更重要？
上面的例子就是保证了透明性，让子节点和叶节点被统一对待，如果调用了二者不支持的方法就直接抛出异常。安全性就需要对调用者做一个判断，如果调用者调用了错误的方法就不执行，这样保证不会抛出异常，但是需要区别调用者。
我们使用组合模式的意图就是为了保持叶节点和子节点的一致性，所以一般更偏重于透明性而不是安全性。
通过上面的例子大家应该对组合模式有了一个感性的认识，那么现在我们来具体看看组合模式的定义
定义
将 对 象 组 合 成 树 形 结 构 以 表 示 “ 部 分 -整 体 ” 的 层 次 结 构 。 组合模式 使 得 用 户 对 单 个 对 象 和组合对象的使用具有一致性。
组合模式的目的就是让客户端不用区分操作的对象是子节点还是叶节点，而是用一种统一的方式来操作。
实现这个目标的关键在于，设计一个抽象的组件类，让它可以代码子节点和叶节点，这样客户端就不需要区分二者，统一操作它们即可。
通常，组合模式都是用树形结构来表示的，通过根节点、子节点、叶节点组合成一颗对象树，这也意味着任何可以使用对象树来描述或者操作的功能，都可以使用组合模式来进行，比如XML解析，层次结构的菜单，iOS中由多个子视图构成的复杂视图，这些都可以使用组合模式来实现。
同时要注意，因为要让客户端统一操作子节点和叶节点，那么他们的抽象类就必须定义包含二者的所有方法，如果调用者调用了它们不支持的方法，可以抛出异常警告。这虽然违反了单一原则，但是在实际开发中是合理的。
好处
-
定义了包含基本对象和组合对象的类层次结构
基本对象可以被组合成更复杂的组合对
象,而这个组合对象又可以被组合,这样不断的递归下去。客户代码中,任何用到基本
对象的地方都可以使用组合对象。
-
简化客户代码
客户可以一致地使用组合结构和单个对象。通常用户不知道 (也不关心)处理的是一个叶节点还是一个组合组件。这就简化了客户代码 , 因为在定义组合的那些类中不需要写一些充斥着选择语句的函数。
-
使 得 更 容 易 增 加 新 类 型 的 组 件
新定义的 C o m p o s i t e 或 L e a f 子 类 自 动 地 与 已 有 的 结 构 和 客
户代码一起工作,客户程序不需因新的 C o m p o n e n t类而改变。
-
使你的设计变得更加一般化
容易增加新组件也会产生一些问题,那就是很难限制组合
中的组件。有时你希望一个组合只能有某些特定的组件。使用 C o m p o s i t e 时,你不能依赖类型系统施加这些约束,而必须在运行时刻进行检查。
使用时机
如果你想表示对象的部分--整体层次结构。可以选用组合模式把整体和部分统一起来，使得层次结构实现更简单，从外部使用这个层次结构也更容易。
如果你希望统一的使用组合结构中的所有对象，这正是组合模式提供的主要功能
