专栏首页是Kerwin啊【一起学系列】之迭代器&组合:虽然有点用不上啦

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

迭代器模式

意图

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

迭代器模式的诞生

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

【开发】: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 = {"宫保鸡丁", "麻辣香锅", "油闷大虾"};

    @Override
    public MyIterator getIterator() {
        return new NameIterator();
    }

    private class NameIterator implements MyIterator {

        private int index;

        @Override
        public boolean hasNext() {
            return index < names.length;
        }

        @Override
        public Object next() {
           return hasNext() ? names[index++] : null;
        }

        NameIterator() {
            index = 0;
        }
    }
}

「迭代器工作类 咖啡菜单」

public class CoffeeRepository implements MyContainer {

    List<String> names = Arrays.asList("雀巢咖啡", "黑糖玛奇朵", "半点寂寞");

    @Override
    public MyIterator getIterator() {
        return new NameIterator();
    }

    private class NameIterator implements MyIterator {

        private int index;

        @Override
        public boolean hasNext() {
            return index < names.size();
        }

        @Override
        public 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){
        // JDK
        List<String> names = Arrays.asList("Han", "John", "Tomams");
        Iterator<String> iterable = names.iterator();
        while (iterable.hasNext()) {
            System.out.println("JDK Iterator: -> " + iterable.next());
        }

        CodeUtils.spilt();

        // JDK
        names.forEach(s -> System.out.println("JDK forEach: -> " + s));
    }
}

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

迭代器模式的设计思路:

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

简单来说,

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

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

遵循的设计原则

  • 单一职责原则

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

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

什么场景适合使用

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

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;
    }

    @Override
    public void add(MenuComponent component) {
        this.menuComponents.add(component);
    }

    @Override
    public void remove(MenuComponent component) {
        this.menuComponents.remove(component);
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public MenuComponent getChild(int i) {
        return menuComponents.get(i);
    }

    @Override
    public void print() {
        System.out.println("当前菜单项: " + getName());
        for (MenuComponent component : menuComponents) {
            component.print();
        }
    }
}

「实现 "部分"」

public class MentItem extends MenuComponent{

    public MentItem(String name) {
        this.name = name;
    }

    @Override
    public void add(MenuComponent component) throws Exception {
        throw new Exception("无法添加");
    }

    @Override
    public void remove(MenuComponent component) throws Exception {
        throw new Exception("无法移除");
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public MenuComponent getChild(int i) throws Exception {
        throw new Exception("无子节点");
    }

    @Override
    public 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 客户端,调用方

简单来说,

  1. 当我们需要树形结构时,抽象叶子节点和组合节点(有子节点的节点)的共同行为
  2. 让两者实现同一个接口

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

什么场景适合使用

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

Code/生活中的实际应用

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

组合模式的UML图

总结

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

相关代码链接

GitHub地址:https://github.com/kkzhilu/Kerwin-DesignPattern

  • 兼顾了《HeadFirst》以及《GOF》两本经典书籍中的案例
  • 提供了友好的阅读指导

本文分享自微信公众号 - 是Kerwin啊(KerwinRoad),作者:柯小贤

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2020-06-15

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 【一起学系列】之剩下的设计模式们

    【BOSS】:没呢,还有好几个设计模式没说过呢,今天再传授你三个吧,分别是建造者模式,责任链模式,备忘录模式,如何?

    Kerwin
  • 【一起学系列】之命令模式:封装一个简单Jedis?

    将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤销的操作。

    Kerwin
  • 【一起学系列】之装饰器模式:不改代码增强功能?

    动态地给一个对象添加一些额外的职责,就增加功能来说,Decorator模式相比生成子类更为灵活

    Kerwin
  • 设计模式二十四章经之抽象工厂模式

    我就是马云飞
  • 快速入门系列--WebAPI--04在老版本MVC4下的调整

    WebAPI是建立在MVC和WCF的基础上的,原来微软老是喜欢封装的很多,这次终于愿意将http编程模型的相关细节暴露给我们了。在之前的介绍中,基本上都基于.N...

    用户1216676
  • ASP.NET MVC5+EF6+EasyUI 后台管理系统(33)-MVC 表单验证

    注:本节阅读需要有MVC 自定义验证的基础,否则比较吃力 一直以来表单的验证都是不可或缺的,微软的东西还是做得比较人性化的,从webform到MVC,都做到了双...

    用户1149182
  • Spring事务失效的 8 大原因,这次可以吊打面试官了!

    这里以 MySQL 为例,其 MyISAM 引擎是不支持事务操作的,InnoDB 才是支持事务的引擎,一般要支持事务都会使用 InnoDB。

    乐哉开讲
  • Spring事务失效的 8 大原因,这次可以吊打面试官了!

    今天再来一篇《吊打面试官》系列,这次真的要吊打了,哈哈!(看往期吊打系列请在后台回复:吊打,我会陆续更新……)

    Java技术栈
  • [设计模式]抽象工厂模式

    简介 抽象工厂模式 (Abstract Factory)提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 抽象工厂模式是一种类创建型模式 ...

    静默虚空
  • ASP.NET Core 添加统一模型验证处理机制

    晓晨

扫码关注云+社区

领取腾讯云代金券