数据结构模式

数据结构模式

       常常有一些组件在内部具有特定的数据结构,如果让客户程序依赖这些特定的数据结构,将极大地破坏组件的复用。这时候,将这些特定数据结构封装在内部,在外部提供统一的接口,来实现与特定结构无关的访问,是一种行之有效的解决方案。

一、Composite组合模式

        当客户代码过多依赖于对象容器复杂的内部结构,对象容器内部实现结构(而非抽象接口)的变化将引起客户代码的频繁变化,带来了代码的维护性、扩展性等弊端。Composite模式将“客户代码与复杂的对象容器结构”解耦,让对象容器自己来实现自身的复杂结构,从而使得客户代码就像处理简单对象一样来处理复杂的对象容器。
示例代码:
public abstract class Component {

    public abstract void process();

}

//树节点
public class Composite extends Component {

    String name;
    Vector<Component> elements;

    public Composite(String s) {
        name = s;
    }

    public void add(Component element) {
        elements.add(element);
    }

    public void remove(Component element) {
        elements.remove(element);
    }

    @Override
    public void process() {
        //1. process current node

        //2. process leaf nodes
        for (Component e  : elements) {
            e.process();//多态调用
        }
    }
}

//叶子节点
public class Leaf extends Component {
    String name;

    public Leaf(String s) {
        name = s;
    }

    @Override
    public void process() {
        //process current node
    }
}



public class  ClientApp{

    public static void invoke(Component c){
        //...
        c.process();
        //...
    }


    public static void main(String args[]) {

        Composite root=new Composite("root");
        Composite treeNode1=new Composite("treeNode1");
        Composite treeNode2=new Composite("treeNode2");
        Composite treeNode3=new Composite("treeNode3");
        Composite treeNode4=new Composite("treeNode4");
        Leaf leat1=new Leaf("left1");
        Leaf leat2=new Leaf("left2");

        root.add(treeNode1);
        treeNode1.add(treeNode2);
        treeNode2.add(leaf1);

        root.add(treeNode3);
        treeNode3.add(treeNode4);
        treeNode4.add(leaf2);

        invoke(root);
        invoke(leaf2);
        invoke(treeNode3);
    }

}


        将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性(稳定)。模式的结构如下图:

        ●  Composite模式采用树形结构来实现普遍存在的对象容器,从而将“一对多”的关系转化成“一对一”的关系,使得客户代码可以一致的(复用)处理对象和对象容器,无需关心处理的是单个对象,还是组合的对象容器;
        ●  将“客户代码与复杂的对象容器结构”解耦是Composite的核心思想,解耦之后,客户代码将与纯粹的抽象接口(而非对象容器的内部实现)发生依赖,从而更能“应对变化”;
        ●  Composite模式在具体实现中,可以让父对象中的子对象反向追溯;如果父对象有频繁的遍历需求,可使用缓存技巧来改善效率。

二、Iterator迭代器

        在软件构建过程中,集合对象内部结构常常变化各异。但对于这些集合对象,我们希望在不暴露其内部结构的同时,可以让外部客户代码透明地访问其中包含的元素;同时这种“透明遍历”也为“同一种算法在多种集合对象上进行操作”提供了可能。使用面向对象技术将这种遍历机制抽象为“迭代器对象”为“应对变化中的集合对象”提供了一种优雅的方式。
        定义:提供一种方法顺序访问一个聚合对象中的各个元素,而又不暴露(稳定)该对象的内部表示。
示例代码:
public class  ClientApp{

    public static void main(String args[]) {

        Vector<String> mc=new Vector<>();
        mc.add("Beijing");
        mc.add("Shanghai");
        mc.add("New York");
        mc.add("Paris");
        mc.add("London");


        Iterator<String> iter = mc.iterator();

        while (iter.hasNext())
        {
            String item =  iterator.next();
            System.out.println(item);
        }


        for(String data: mc){
            System.out.println(data);
        }
    }

}
        迭代抽象:访问一个聚合对象的内容而无需暴露它的内部表示。
        迭代多态:为遍历不同的集合结构提供一个统一的接口,从而支持同样的算法在不同的集合结构上进行操作。
        迭代器的健壮性考虑:遍历的同时更改迭代器所在的集合结构,会导致问题。
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值