【一起学系列】之迭代器组合：虽然有点用不上啦

迭代器模式

意图

提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴漏该对象的内部表示

迭代器模式的诞生

【产品】：嘿，有一个好消息，咱们旗下的餐厅把月巴克的咖啡店吞并了！太棒了！年终奖稳了！

【开发】：Yeah！Yeah！Yeah！

【产品】：但是他们好像反应一个问题，月巴克的点餐系统好像不兼容我们的体系，怎么回事？不就是一个菜单吗？

【开发】：Oh！No！一定它们的数据结构不一样导致的，遍历出现了问题！

【产品】：那怎么办？BOSS，你们一起想想办法吧！

【开发】：老大，我们能不能把遍历方法抽取出来啊？我们遍历操作就可以不用考虑各种细节了，只需要管遍历类就好了。

【BOSS】：什么遍历类的，这叫迭代器好吗！其实JDK对于迭代器已经维护的很好了，但是咱们这业务也有一点特殊性，就按你说的办吧，办不好的话，刚才说的年终奖就没了。

【开发】：哦，好的（脸上笑嘻嘻，心里MMP）

HeadFirst 核心代码

自己整一个迭代器

定义迭代器持有者非必须代码

/*** ******************************* description:  迭代器持有者* *******************************/
public interface MyContainer {MyIterator getIterator();
}

迭代器接口

/*** ******************************* description:  迭代器接口* *******************************/
public interface MyIterator {boolean hasNext();Object next();
}

迭代器工作类食物菜单

public class FoodRepository implements MyContainer {String[] names = {"宫保鸡丁", "麻辣香锅", "油闷大虾"};@Overridepublic MyIterator getIterator() {return new NameIterator();}private class NameIterator implements MyIterator {private int index;@Overridepublic boolean hasNext() {return index < names.length;}@Overridepublic Object next() {return hasNext() ? names[index++] : null;}NameIterator() {index = 0;}}
}

迭代器工作类咖啡菜单

public class CoffeeRepository implements MyContainer {List<String> names = Arrays.asList("雀巢咖啡", "黑糖玛奇朵", "半点寂寞");@Overridepublic MyIterator getIterator() {return new NameIterator();}private class NameIterator implements MyIterator {private int index;@Overridepublic boolean hasNext() {return index < names.size();}@Overridepublic Object next() {return hasNext() ? names.get(index++) : null;}NameIterator() {index = 0;}}
}

测试类观察调用的表现形式

public class App {public static void main(String[] args){// 餐厅菜单FoodRepository food = new FoodRepository();MyIterator foodIterator = food.getIterator();while (foodIterator.hasNext()) {System.out.println("Food: -> " + foodIterator.next());}CodeUtils.spilt();// 咖啡菜单CoffeeRepository coffee = new CoffeeRepository();MyIterator coffeeIterator = coffee.getIterator();while (coffeeIterator.hasNext()) {System.out.println("Coffee: -> " + coffeeIterator.next());}}
}

JDK中的迭代

public class App {public static void main(String[] args){// JDKList<String> names = Arrays.asList("Han", "John", "Tomams");Iterator<String> iterable = names.iterator();while (iterable.hasNext()) {System.out.println("JDK Iterator: -> " + iterable.next());}CodeUtils.spilt();// JDKnames.forEach(s -> System.out.println("JDK forEach: -> " + s));}
}

因此对于业务上没有什么要求且常见的数据结构，我们不再需要自行定义迭代器

迭代器模式的设计思路：

Iterator 迭代器
Concretelterator 具体迭代器
Aggregate 集合
ConcreteAggregate 具体集合

简单来说，

我们需要明确集合的类型（数组，链表，Map，树结构或者普通List）
我们需要定义迭代器的行为，是否有下一个（遍历完成），取值，移除等等
遍历的行为或者算法在具体的迭代器中实现，根据不同的数据结构和业务要求完成编码，实现访问一致，但细节不同的效果

如果看着有点模棱两可，就看完本文后，访问专题设计模式开源项目，里面有具体的代码示例，链接在最下面

遵循的设计原则

单一职责原则

说明：迭代器类在设计中仅仅包含集合迭代的作用，它是把原本数据结构中的遍历抽取出来，达到高内聚的效果。

所谓高内聚：当一个模块或一个类被设计成只支持一组相关功能时，我们说它具有高内聚的特征。

什么场景适合使用

访问一个聚合对象的内容而无需暴漏它的内部表示
支持对聚合对象的多种遍历
为遍历不同的聚合结构提供一个统一的接口

Code/生活中的实际应用

举一个不是很恰当的例子，我们都用自动贩卖机买过水，付钱之后它会自动滚出来，大家有没有想过它是怎么实现这个效果的呢？它支持瓶装的，罐装的，甚至还支持袋装的，方便面，口红等等五花八门的产品，它的内部结构可能都各不相同，但是最终的表现效果就是我们直接从出口处拿即可，这是不是迭代器模式的一种体现呢？

迭代器模式UML图

组合模式

意图

将对象组合成树形结构以表示 “部分-整体” 的层次结构，Composite使得用户对单个对象和组合对象的使用具有一致性

说人话：想想Java里的File类

组合模式的误区

组合模式不是一堆模式的组合！

组合模式的诞生

【开发】：老大，我在写菜单类的时候感觉好痛苦啊！

【BOSS】：怎么了？

【开发】：菜单有真正的菜品，还有父级菜单啊，它们俩得维护两套逻辑，混在一起好难受！

【BOSS】：你在操作文件的时候怎么不觉得难受？你咋不动动脑子想着抽象一下啊！

【开发】：对啊！我去改代码！

HeadFirst 核心代码

定义抽象行为

/*** ******************************* description:  定义抽象行为* *******************************/
public abstract class MenuComponent {public String name;/**** 添加*/public abstract void add(MenuComponent component) throws Exception;/**** 移除*/public abstract void remove(MenuComponent component) throws Exception;/**** 获取菜单名*/public abstract String getName();/**** 获取子菜单*/public abstract MenuComponent getChild(int i) throws Exception;/**** 打印菜单*/public abstract void print();
}

实现 “整体”

public class Menu extends MenuComponent{List<MenuComponent> menuComponents = new ArrayList<>();public Menu(String name) {this.name = name;}@Overridepublic void add(MenuComponent component) {this.menuComponents.add(component);}@Overridepublic void remove(MenuComponent component) {this.menuComponents.remove(component);}@Overridepublic String getName() {return this.name;}@Overridepublic MenuComponent getChild(int i) {return menuComponents.get(i);}@Overridepublic void print() {System.out.println("当前菜单项: " + getName());for (MenuComponent component : menuComponents) {component.print();}}
}

实现 "部分"

public class MentItem extends MenuComponent{public MentItem(String name) {this.name = name;}@Overridepublic void add(MenuComponent component) throws Exception {throw new Exception("无法添加");}@Overridepublic void remove(MenuComponent component) throws Exception {throw new Exception("无法移除");}@Overridepublic String getName() {return this.name;}@Overridepublic MenuComponent getChild(int i) throws Exception {throw new Exception("无子节点");}@Overridepublic void print() {System.out.println("    食物名: " + getName());}
}

测试类

public class App {/**** 推荐代码阅读顺序：** @see MenuComponent* @see Menu* @see MentItem*/public static void main(String[] args) {Menu meat = new Menu("炒菜类");MentItem item1 = new MentItem("宫保鸡丁");MentItem item2 = new MentItem("剁椒鸡蛋");MentItem item3 = new MentItem("鱼香肉丝");Menu vegetable = new Menu("素食");MentItem v1 = new MentItem("酸辣土豆丝");MentItem v2 = new MentItem("爆炒包菜");meat.add(item1);meat.add(item2);meat.add(item3);vegetable.add(v1);vegetable.add(v2);meat.add(vegetable);meat.print();}
}/**** 输出内容：** 当前菜单项: 炒菜类*     食物名: 宫保鸡丁*     食物名: 剁椒鸡蛋*     食物名: 鱼香肉丝* 当前菜单项: 素食*     食物名: 酸辣土豆丝*     食物名: 爆炒包菜*/

组合模式的设计思路：

Component 为组合的对象声明接口或抽象类
Leaf 叶子节点（最小单元）
Composite 组合节点（即还有子节点的节点）
Client 客户端，调用方

简单来说，

当我们需要树形结构时，抽象叶子节点和组合节点（有子节点的节点）的共同行为
让两者实现同一个接口

如果看着有点模棱两可，就看完本文后，访问专题设计模式开源项目，里面有具体的代码示例，链接在最下面

什么场景适合使用

需要表示对象的部分-整体层次结构
希望用户忽略组合对象与单个对象的不同，用户统一地使用组合结构中所有对象

Code/生活中的实际应用

依然是一个不太恰当的例子，我们在操作文件和文件夹的时候，都有其移动，复制，重命名，查看文件大小等等功能，对于Java来说，它的底层实现是有一个 是否是文件夹的方法来区分，但实际上这也是组合模式的根本思想，即对于表示部分的对象，和整体的对象，拥有统一的操作行为

组合模式的UML图

总结

迭代器模式：该模式在JDK中已经封装的非常好，我们其实不太需要再自行处理，不过在处理特殊数据结构时这种统一操作的思想仍然值得借鉴
组合模式：组合模式仅在需要树形结构的场景下可发挥巨大的作用，同样的，它规范不同类型对象的行为，统一操作的思想，值得我们借鉴