设计模式：（六）迭代器、观察者、中介者、备忘录模式

已于 2022-10-04 09:42:48 修改
阅读量243 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 迭代器模式 观察者模式 中介者模式 备忘录模式
于 2021-04-08 22:27:23 首次发布
余笙
本文链接：https://blog.csdn.net/qq_42200163/article/details/115533319
版权

一、迭代器模式

1、概述

1、迭代器（Iterator）模式：提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素， 不需要知道集合对象的底层表示（即：不暴露其内部的结构）。迭代器模式是一种对象行为型模式。

2、主要角色

1、抽象迭代器（Iterator）：定义访问和遍历聚合元素的接口，通常包含hasNext()、next()、remove()等方法。
2、具体迭代器（Concretelterator）：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。
3、抽象聚合（Aggregate）：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
4、具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

3、迭代器模式实现

/**
 * 具体迭代器
 */
public class InfoColleageIterator implements Iterator {
    /**
     * 以list方式存放数据
     */
    List<Department> list;

    public InfoColleageIterator(List<Department> list) {
        this.list = list;
    }

    //索引位置
    int index = -1;

    /**
     * 判断集合中是否有下一个元素
     * @return
     */
    @Override
    public boolean hasNext() {
        if (index >= list.size() - 1) {
            return false;
        } else {
            index += 1;
            return true;
        }
    }

    /**
     * 获取数据
     * @return
     */
    @Override
    public Object next() {
        return list.get(index);
    }
}

/**
 * 具体迭代器
 */
public class ComputerCollegeIterator implements Iterator {
    /**
     * 以数组方式存放数据
     */
    Department[] departments;

    public ComputerCollegeIterator(Department[] departments) {
        this.departments = departments;
    }

    //遍历位置
    int position = 0;

    /**
     * 判断是否有下一个元素
     * @return
     */
    @Override
    public boolean hasNext() {
        if (position >= departments.length || departments[position] == null) {
            return false;
        }
        return true;
    }

    /**
     * 取出数据
     * @return
     */
    @Override
    public Object next() {
        Department department = departments[position];
        position += 1;
        return department;
    }
}

/**
 * 系别属性
 */
@Data
@AllArgsConstructor
public class Department {
    private String name;

    private String desc;
}

/**
 * 抽象聚合
 */
public interface ColleageAggregate {
    public String getName();

    /**
     * 增加系的方法
     * @param name
     * @param desc
     */
    public void add(String name,String desc);

    /**
     * 返回迭代器
     * @return
     */
    public Iterator createIterator();
}

/**
 * 具体聚合
 */
public class InfoAggregate implements ColleageAggregate {
    List<Department> departments;

    public InfoAggregate() {
        departments = new ArrayList<>();
        add("信息安全","保障信息安全");
        add("数据库安全","保障数据库安全");
        add("服务器安全","保障服务器安全");
    }

    @Override
    public String getName() {
        return "信息工程学院";
    }

    @Override
    public void add(String name, String desc) {
        Department department = new Department(name, desc);
        departments.add(department);
    }

    @Override
    public Iterator createIterator() {
        return new InfoColleageIterator(departments);
    }
}

public class ComputerAggregate implements ColleageAggregate {
    Department[] departments;

    public ComputerAggregate() {
        departments = new Department[5];
        add("Java","后台服务");
        add("MySQL","提供数据");
        add("HTML + CSS","美化页面");
    }

    //保存当前数据的对象个数
    int num = 0;

    @Override
    public String getName() {
        return "计算机学院";
    }

    @Override
    public void add(String name, String desc) {
        Department department = new Department(name, desc);
        departments[num] = department;
        num += 1;
    }

    @Override
    public Iterator createIterator() {
        return new ComputerCollegeIterator(departments);
    }
}

/**
 * 测试
 */
public class Client {
    public static void main(String[] args) {
        List<ColleageAggregate> colleage = new ArrayList<>();
        ComputerAggregate colleageAggregate = new ComputerAggregate();
        InfoAggregate infoAggregate = new InfoAggregate();

        colleage.add(colleageAggregate);
        colleage.add(infoAggregate);
        //取出所有学院，
        Iterator<ColleageAggregate> iterator = colleage.iterator();
        while (iterator.hasNext()) {
            ColleageAggregate next = iterator.next();
            System.out.println("==========" + next.getName() + "==========");
            //获取系别迭代器
            Iterator iterator1 = next.createIterator();
            while (iterator1.hasNext()) {
                Department department = (Department) iterator1.next();
                System.out.println(department.getName());
            }
        }
    }
}

/**
 * 运行结果：
 * ==========计算机学院==========
 * Java
 * MySQL
 * HTML + CSS
 * ==========信息工程学院==========
 * 信息安全
 * 数据库安全
 * 服务器安全
 */

4、优缺点说明

1、优点：
  • 提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以遍历对象了。
  • 隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成。
  • 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
  • 增加新的聚合类和迭代器类都很方便，无须修改原有代码。
  • 封装性良好，为遍历不同的聚合结构提供一个统一的接口。
2、缺点：
  • 增加了类的个数，这在一定程度上增加了系统的复杂性。

5、应用场景

1、当需要为聚合对象提供多种遍历方式时。
2、当需要为遍历不同的聚合结构提供一个统一的接口时。
3、当访问一个聚合对象的内容而无须暴露其内部细节的表示时。
4、总结：由于聚合与迭代器的关系非常密切，所以大多数语言在实现聚合类时都提供了迭代器类，因此大数情况下使用语言中已有的聚合类的迭代器就已经够了。

二、观察者模式

1、概述

1、观察者（Observer）模式：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式。

2、主要角色

1、抽象主题（Subject）：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
2、具体主题（Concrete Subject）：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
3、抽象观察者（Observer）：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
4、具体观察者（Concrete Observer）：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

3、观察者模式实现

/**
 * 抽象主题
 */
public interface Subject {
    /**
     * 增加观察者方法
     * @param observer
     */
    void addObserver(Observer observer);

    /**
     * 移除方法
     * @param observer
     */
    void removeObserver(Observer observer);

    /**
     * 通知方法
     */
    void notifyObserver();
}

/**
 * 具体主题
 * 含有观察者集合，使用ArrayList管理
 * 当有数据更新时，就主动调用ArrayList，通知所有的（接入方）就看到最新的信息
 */
@Getter
public class ConcreteSubject implements Subject {
    //温度
    private float temperature;
    //气压
    private float pressure;
    //湿度
    private float humidity;
    //观察者集合
    private ArrayList<Observer> observers;

    public ConcreteSubject() {
        observers = new ArrayList<Observer>();
    }

    /**
     * 当有数据更新时，就调用setData
     * @param temperature
     * @param pressure
     * @param humidity
     */
    public void setData(float temperature,float pressure,float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        //调用dataChange，将最新消息推送到接入方
        dataChange();
    }

    /**
     * 更新所有通知
     */
    public void dataChange(){
        notifyObserver();
    }

    /**
     * 添加一个观察者
     * @param observer
     */
    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    /**
     * 移除一个观察者
     * @param observer
     */
    @Override
    public void removeObserver(Observer observer) {
        if (observers.contains(observer)) {
            observers.remove(observer);
        }
    }

    /**
     * 遍历所有的观察者，并通知
     */
    @Override
    public void notifyObserver() {
        for (int i = 0; i < observers.size(); i++) {
            observers.get(i).update(this.temperature,this.pressure,this.humidity);
        }
    }
}

/**
 * 抽象观察者
 */
public interface Observer {
    /**
     * 更新方法
     * @param temperature
     * @param pressure
     * @param humidity
     */
    void update(float temperature,float pressure,float humidity);
}

/**
 * 具体观察者
 */
public class ConcreteObserver implements Observer {
    //温度
    private float temperature;
    //气压
    private float pressure;
    //湿度
    private float humidity;

    /**
     * 更新方法
     * @param temperature
     * @param pressure
     * @param humidity
     */
    @Override
    public void  update(float temperature, float pressure, float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }

    /**
     * 显示结果
     */
    private void display() {
        System.out.println("温度：" + temperature);
        System.out.println("气压：" + pressure);
        System.out.println("湿度：" + humidity);
    }
}

/**
 * 测试
 */
public class Client {
    public static void main(String[] args) {
        //创建一个具体主题对象
        ConcreteSubject concreteSubject = new ConcreteSubject();
        //创建观察者对象
        ConcreteObserver concreteObserver = new ConcreteObserver();
        //添加到concreteSubject
        concreteSubject.addObserver(concreteObserver);
        System.out.println("通知各个观察者。查看信息");
        concreteSubject.setData(19f,100f,30f);
    }
}
/**
 * 运行结果：
 * 通知各个观察者。查看信息
 * 温度：19.0
 * 气压：100.0
 * 湿度：30.0
 */

4、优缺点说明

1、优点：
  • 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。
  • 目标与观察者之间建立了一套触发机制。
2、缺点：
  • 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
  • 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

5、应用场景

1、在软件系统中，当系统一方行为依赖另一方行为的变动时，可使用观察者模式松耦合联动双方，使得一方的变动可以通知到感兴趣的另一方对象，从而让另一方对象对此做出响应。
  • 对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。
  • 当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
  • 实现类似广播机制的功能，不需要知道具体收听者，只需分发广播，系统中感兴趣的对象会自动接收该广播。
  • 多层级嵌套使用，形成一种链式触发机制，使得事件具备跨域（跨越两种观察者类型）通知。

三、中介者模式

1、概述

1、中介者（Mediator）模式：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。

2、主要角色

1、抽象中介者（Mediator）：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
2、具体中介者（Concrete Mediator）：实现中介者接口，定义一个集合来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
3、抽象同事类（Colleague）：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
4、具体同事类（Concrete Colleague）：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

3、中介者模式实现

/**
 * 抽象中介者
 */
public abstract class Mediator {
    public abstract void register(Colleague colleague);

    public abstract void relay(Colleague cl);
}

/**
 * 具体中介者
 */
public class ConcreteMediator extends Mediator {
    //存放所有同事对象
    private List<Colleague> colleagues = new ArrayList<Colleague>();

    @Override
    public void register(Colleague colleague) {
        if (!colleagues.contains(colleague)) {
            colleagues.add(colleague);
            colleague.setMedium(this);
        }
    }

    @Override
    public void relay(Colleague cl) {
        for (Colleague ob : colleagues) {
            if (!ob.equals(cl)) {
                ((Colleague) ob).receive();
            }
        }
    }
}

/**
 * 抽象同事类
 */
public abstract class Colleague {
    protected Mediator mediator;

    public void setMedium(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void receive();

    public abstract void send();
}

/**
 * 具体同事类1
 */
public class ConcreteColleague1 extends Colleague {

    @Override
    public void receive() {
        System.out.println("具体同事类1收到请求。");
    }
    @Override
    public void send() {
        System.out.println("具体同事类1发出请求。");
        //请中介者转发
        mediator.relay(this);
    }
}

/**
 * 具体同事类2
 */
public class ConcreteColleague2 extends Colleague {

    @Override
    public void receive() {
        System.out.println("具体同事类2收到请求。");
    }

    @Override
    public void send() {
        System.out.println("具体同事类2发出请求。");
        //请中介者转发
        mediator.relay(this);
    }
}

/**
 * 测试
 */
public class Client {
    public static void main(String[] args) {
        //创建中介者对象
        Mediator md = new ConcreteMediator();
        Colleague c1, c2;
        c1 = new ConcreteColleague1();
        c2 = new ConcreteColleague2();
        md.register(c1);
        md.register(c2);
        c1.send();
        System.out.println("=================");
        c2.send();
    }
}

/**
 * 运行结果：
 * 具体同事类1发出请求。
 * 具体同事类2收到请求。
 * =================
 * 具体同事类2发出请求。
 * 具体同事类1收到请求。
 */

4、优缺点说明

1、优点：
  • 类之间各司其职，符合迪米特法则。
  • 降低了对象之间的耦合性，使得对象易于独立地被复用。
  • 将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。
2、缺点：
  • 中介者模式将原本多个对象直接的相互依赖变成了中介者和多个同事类的依赖关系。当同事类越多时，中介者就会越臃肿，变得复杂且难以维护。

5、应用场景

1、当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。
2、当想创建一个运行于多个类之间的对象，又不想生成新的子类时。si

四、备忘录模式

1、概述

1、备忘录（Memento）模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态。该模式又叫快照模式。

2、主要角色

1、发起人（Originator）：记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录数据的功能，实现其他业务功能，它可以访问备忘录里的所有信息。
2、备忘录（Memento）：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人。
3、管理者（Caretaker）：对备忘录进行管理，提供保存与获取备忘录的功能，但其不能对备忘录的内容进行访问与修改。

3、备忘录模式实现

/**
 * 发起人
 */
public class Originator {
    private String state;

    public void setState(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public Memento createMemento() {
        return new Memento(state);
    }

    public void restoreMemento(Memento m) {
        this.setState(m.getState());
    }
}

/**
 * 备忘录
 */
@Data
@AllArgsConstructor
public class Memento {
    private String state;
}

/**
 * 管理者
 */
public class Caretaker {
    private Memento memento;

    public void setMemento(Memento m) {
        memento = m;
    }

    public Memento getMemento() {
        return memento;
    }
}

/**
 * 测试
 */
public class Client {
    public static void main(String[] args) {
        Originator or = new Originator();
        Caretaker cr = new Caretaker();
        or.setState("S0");
        System.out.println("初始状态:" + or.getState());
        //保存状态
        cr.setMemento(or.createMemento());
        or.setState("S1");
        System.out.println("新的状态:" + or.getState());
        //恢复状态
        or.restoreMemento(cr.getMemento());
        System.out.println("恢复状态:" + or.getState());
    }
}
/**
 * 运行结果：
 * 初始状态:S0
 * 新的状态:S1
 * 恢复状态:S0
 */

4、优缺点说明

1、优点：
  • 提供了一种可以恢复状态的机制。当用户需要时能够比较方便地将数据恢复到某个历史的状态。
  • 实现了内部状态的封装。除了创建它的发起人之外，其他对象都不能够访问这些状态信息。
  • 简化了发起人类。发起人不需要管理和保存其内部状态的各个备份，所有状态信息都保存在备忘录中，并由管理者进行管理，这符合单一职责原则。
2、缺点：
  • 资源消耗大。如果要保存的内部状态信息过多或者特别频繁，将会占用比较大的内存资源。

5、应用场景

1、需要保存与恢复数据的场景，如玩游戏时的中间结果的存档功能。
2、需要提供一个可回滚操作的场景，如 Word、记事本、Photoshop，Eclipse 等软件在编辑时按 Ctrl+Z 组合键，还有数据库中事务操作。
小幸运安然
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
day05 状态+观察者+备忘录+迭代器+中介者+访问者
10-18
状态模式 状态模式是一种行为型模式，它允许对象在其内部状态改变时改变其行为。...状态模式是一种非常有用的设计模式，它可以帮助我们封装对象的状态和行为，并使得对象的状态可以根据需要进行变化。
【备忘录设计模式详解】C/Java/JS/Go/Python/TS不同语言实现
04-20 250
备忘录模式（Memento Pattern）是一种结构型设计模式。这种模式就是在不破坏封装的条件下，将一个对象的状态捕捉(Capture)住，并放在外部存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。备忘录模式常常与命令模式和迭代子模式一同使用。备忘录模式的角色有三个：备忘录(Memento)角色、发起人(Originator)角色、负责人(Caretaker)角色备忘录模式是由发起人（Originator）对象负责生成状态快照，其他对象不可修改状态。
迭代器模式与观察者模式
攻城老湿的博客
06-27 135
迭代器模式与观察者模式 参考教程：https://www.bilibili.com/video/BV1G4411c7N4 代码实现 Github：https://github.com/yaokuku123/pattern 迭代器模式 案例 编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。如图： 5-1592899...
设计模式化--迭代器模式和观察者模式
weixin_38705074的博客
10-26 138
1、迭代器模式 package com.yqj.pattern.iterator; import java.util.ArrayList; import java.util.Iterator; import java.util.List; class Department { private String name; private String desc; public Department(String name, String desc) { this.n
软件架构设计师-行为型模式-中介者模式-观察者模式-迭代器模式-C++
插件开发
04-18 179
文章目录1.中介者模式2.观察者模式3.迭代器模式(Iterator Pattern)4.作者答疑   本文定义模式设计中行为型模式的解析，主要讲解中介者模式，观察者模式和迭代器模式。本文内容来至互联网内容的编辑修改，方便读者学习。如有侵权，第一时间联系作者删除。 1.中介者模式   定义:用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 Mediator：中介者，它定义了一个接口用于与各个Colleague对象通信； Conc
观察者模式（Observer）--迭代器模式（Iterator）
02-03 405
15、观察者模式（Observer） 包括这个模式在内的接下来的四个模式，都是类和类之间的关系，不涉及到继承。 当你订阅了该文章，如果后续有更新，会及时通知你。对象之间是一种一对多的关系。 MySubject类就是被观察者。 public interface Observer {       public void update();   }   public class Obs...
java-design-patterns-PPT.zip_观察者模式ppt
09-14
3. **行为型模式**: 包括观察者模式在内的模式，如策略模式、模板方法模式、职责链模式、命令模式、迭代器模式、访问者模式、备忘录模式、解释器模式，它们关注对象间的交互和行为。 **观察者模式的优势** 1. **松...
二十三种设计模式图解(自学)
01-27
5. **观察者模式**：定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。 6. **装饰器模式**：动态地给对象添加一些额外的职责，既扩展了功能，又不破坏...
python实现常用的23种设计模式：含源代码、详细文档说明
07-12
2、观察者模式【Observer】 3、状态模式【State】 4、策略模式【Strategy】 5、职责链模式【Chain of Responsibility】 6、命令模式【Command】 7、访问者模式【Visitor】 8、调停者模式【Mediator】 9、备忘录模式...
Java设计模式面试题汇总
最新发布
10-01
包括责任链模式、命名模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板模式、访问者模式等。 常见设计模式： 工厂模式：工厂模式指由一个工厂对象来创建实例，客户端...
设计模式--观察者模式和迭代器模式
咸鱼梦想
01-02 332
本来想着转载一份博客，但是总感觉加一些自己的思考与想法，写写博客，练习一下表达能力 观察者模式 //观察者模式 // 是软件设计模式的一种。在此种模式中，一个目标对象管理所有相依于它的观察者对象，并且在它本身的状态改变时主动发出通知。这 通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实时事件处理系统。 1.当观察者增多时，直接添加新的观察者，之后再将其注册，这样关注的特性发生改变...
设计模式访问者模式-迭代器模式-观察者模式
冰山丶
04-09 214
设计模式访问者模式-迭代器模式-观察者模式 访问者模式 基本介绍 访问者模式，封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新操作。 主要将数据结构和数据操作分离，解决数据结构和操作耦合性问题。 访问者模式的工作原理：在被访问的类里面加一个对外提供接待访问者的接口。 访问者模式主要应用场景是：需要对一个对象结构中的对象进行很多不同操作（这些操作...
Java设计模式（八）观察者模式 迭代器模式
fanyun7654的专栏
07-11 1122
（十五）观察者模式 观察者模式，定义对象间一对多关系，一个对象状态发生改变，所有依赖于它的对象都收到通知并且自动更新，观察者与被观察者分开。例如邮件订阅、RSS订阅，如果有更新就会邮件通知你。 （十六）迭代器模式 说到迭代器首先想到 Iterator ，使用迭代器来为顺序访问集合元素提供一种方式。下面是自己的一个集合，当然只能放 int ，简单的实现了 迭代器的功能，当然实际的Java迭代器比这要复杂很多。
设计模式示例四 Observer(观察者)和Iterator(迭代器)
aitanwu4387的博客
02-22 97
之所以把这两个模式放在一起说是因为C#语句的关系。这两种模式实现起来变得很轻松或者说不一样了。Observer(观察者) classObserver{publicdelegatevoidEventHandler(stringstate);publiceventEventHandlerchangeEvent;...
[设计模式](十一)：观察者模式|迭代器模式|责任链模式|命令模式（四种类间行为模式）
身披白袍的博客
08-22 1498
观察者模式|迭代器模式|责任链模式|命令模式，这是四种类间行为模式
Day318.迭代器模式&观察者模式 -Java设计模式
阿昌爱Java
07-04 282
迭代器模式 关注在数据遍历 一、需求 编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院， 一个学院有多个系。如图： 二、传统的设计方案(类图) 三、传统的方式的问题分析 1)将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的 2)实际上我们的要求是 ：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系， 因此这种方案，不能很好实现的遍历的操作 3)解决方案：=> 迭代器模式 四、迭代器模式基本介绍 基
设计模式（十）观察者模式 备忘录模式
Aero's WorkSpace.
05-14 243
观察者模式 定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。 实际上，观察者模式只是典型的回调机制，可以广播。比较简单，就不多叙述了。 备忘录模式 意思是：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样，以后就可以将该对象恢复到原先保存的状态。 ■ 发起人（Originator）角色：该角色记录当...
中介者模式
sinat_32787481的博客
10-25 122
中介者模式通过提供了一个中介类，处理不同类之间复杂的引用关系；将一个网状的系统结构变成一个以中介者对象为中心的星形结构。 public interface Mediator { void broadcast(ChatUser chatUser, String message); } public class ChatMediator implements Mediator { ...
行为型设计模式解析：责任链、迭代器、中介者等
2、**迭代器模式 (Iterator)**：迭代器模式提供了一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。它定义了遍历元素的接口，使得可以在不暴露聚合类内部结构的情况下访问聚合类的元素。 3、**中介者模式 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值