什么是迭代器模式、中介者模式和观察者模式
这篇文章主要讲解了"什么是迭代器模式、中介者模式和观察者模式"，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习"什么是迭代器模式、中介者模式和观察者模式"吧！
迭代器模式
一听这名字就很熟悉，对于java程序员来说，遍历集合还是比较常见的操作。不用关心类型，就能够访问数据，用的就是迭代器模式。
Aggregate(抽象容器)： 应该由所有类实现的抽象类，并且科研由迭代器遍历。类似Collection接口
Iterator(抽象迭代器)： 定义遍历容器对象的操作以及返回对象的操作
Concrete Aggregate(具体容器)
Concrete Iterator(具体迭代器)
迭代器UML：
Aggregate：
public interface Aggregate { MyIterator createIterator();}Iterator：
public interface MyIterator { Object next(); boolean hasNext();}Concrete Aggregate:
其中这个具体的容器内部有个内部类ConCreateIterator
public class ConcreteAggregate implements Aggregate{ private String[] values; public ConcreteAggregate(String[] values) { this.values = values; } @Override public MyIterator createIterator() { return new ConcreteIterator(); } //内部类，具体的迭代器类 private class ConcreteIterator implements MyIterator { private int position; @Override public Object next() { if (this.hasNext()) { return values[position++]; } return null; } @Override public boolean hasNext() { return position < values.length; } }}Client：
public class Client { public static void main(String[] args) { String[] arr = {"h", "e", "l", "l", "o"}; ConcreteAggregate strarr = new ConcreteAggregate(arr); for (MyIterator it = strarr.createIterator(); it.hasNext(); ) { System.out.println(it.next()); } }}观察者模式
观察者模式定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。
Subject(主题)： 通常由类实现的可观察的接口。一般有添加、删除观察者，以及提醒观察者更新
Concrete Subject(具体主题)： 实现了主题接口，并且通知观察者们更新
Observer(观察者)： 观察者的接口，一般都会有一个update方法
Concrete Observer
观察者UML：
Observer：
public interface Observer { void update(String message);}Concrete Observer：
public class ConcreteObserver implements Observer { @Override public void update(String message) { System.out.println("订阅的公众号有新的消息：" + message); }}Subject：
public interface Subject { List subscribers = new ArrayList<>(); void attach(Observer observer); void detach(Observer observer); void notifySubscribers(String message);} Concrete Subject：
public class ConcreteSubjectDesignPattern implements Subject { @Override public void attach(Observer observer) { subscribers.add(observer); System.out.println("新增一位用户关注"); } @Override public void detach(Observer observer) { subscribers.add(observer); System.out.println("一位用户取消关注"); } @Override public void notifySubscribers(String message) { for (Observer subscriber : subscribers) { subscriber.update(message); } } //这个方法不是通用的，每个具体的主题可能有不同的方法 public void deliver(String message) { notifySubscribers(message); }}中介者模式
中介者模式又称调停模式，在我们现实生活中也会又很多中介者的存在，房屋中介者，合同中介者，在java中的中介者模式又会是什么样子的呢。
现在有个这样的需求，moba类竞技游戏一般来说有五个位置，打野，法术输出，物理输出，辅助，坦克。为了简便呢，就拿三个位置来看。
法师自己可以消耗，但是也会请求支援，打野呢，除了打野怪之外也要去gank，辅助要给大家占视野，同时也要回城补状态。
中介者UML
普通模式
Apc类:
public class Apc { public void poke() { System.out.println("法师消耗"); } //请求支援，需要打野和辅助帮忙 public void help() { Jungle jungle = new Jungle(); Support support = new Support(); System.out.println("法师请求支援"); jungle.daye(); support.vision(); }}Jungle类：
public class Jungle { public void daye() { System.out.println("打野打野"); } //打野要gank了，法师和辅助要跟着一起配合 public void gank() { Apc apc = new Apc(); Support support = new Support(); System.out.println("打野开始抓人："); apc.poke(); support.vision(); }}Support类：
public class Support { public void vision() { System.out.println("辅助占视野"); } //辅助先回城补状态了，你们先猥琐发育 public void back() { Apc apc = new Apc(); Jungle jungle = new Jungle(); System.out.println("辅助暂时回城了："); apc.poke(); jungle.daye(); }}Client类：
之前用测试方法，觉得不是特别好，所以以后还是加个client类给各位小伙伴看。
public class Client { public static void main(String[] args) { Apc apc = new Apc(); Jungle jungle = new Jungle(); Support support = new Support(); apc.help(); jungle.gank(); support.back(); }}确实可以像我们想象的一样，各职位互相协作，但是每次需要合作之前都需要new一下其它对象，这样其实是很不利于松耦合的，各个类之间都相互练习在一起，牵一发而动全身 。为了降低耦合度，中介者模式就出现了。
中介者模式
当然需求还是上面的需求，只不过多了几个类，抽象中介者，具体中介者，抽象同事类，具体同事类
Mediator： 抽象中定义了参与者的交互方式
Concrete Mediator
Colleague： 这是一个抽象类或接口用于定义需要调解的参与者如何进行交互
Concrete Colleague
AbstractMediator类：
public abstract class AbstractMediator { public abstract void help(); public abstract void gank(); public abstract void back();}Mediator类：
public class Mediator extends AbstractMediator { //具体中介者类要知道自己给谁进行中介调停 Apc apc; Jungle jungle; Support support; public Mediator() { this.apc = new Apc(this); this.jungle = new Jungle(this); this.support = new Support(this); } public void help() { System.out.println("法师请求支援"); jungle.daye(); support.vision(); } public void gank() { System.out.println("打野开始抓人："); apc.poke(); support.vision(); } public void back() { System.out.println("辅助暂时回城了："); apc.poke(); jungle.daye(); }}AbstractHero类（抽象同事类）：
public abstract class AbstractHero { //和具体中介者产生一个联系关系 Mediator mediator; public AbstractHero(Mediator mediator) { this.mediator = mediator; }}为了减少篇幅呢，具体英雄类我就只拿Jungle类来讲，其它都是一样的
Jungle类（具体同事类）：
public class Jungle extends AbstractHero { //首先注入中介者 public Jungle(Mediator mediator) { super(mediator); } //属于自己干的事情的还是一样，也可以多几个方法 public void daye() { System.out.println("打野打野"); } //设计到别人的事情，几个人一起合作的事情呢 //也不用自己联系他人，直接跟中介者说下，交给中介者来办 public void gank() { this.mediator.gank(); }}至于其它的同事类都是一样的，注入一个中介者，把耦合度高的事情交给中介者
Client类：
public class Client { public static void main(String[] args) { Mediator mediator = new Mediator(); Apc apc = new Apc(mediator); Jungle jungle = new Jungle(mediator); Support support = new Support(mediator); apc.help(); System.out.println("------------------------------"); jungle.gank(); System.out.println("------------------------------"); support.back(); }}感谢各位的阅读，以上就是"什么是迭代器模式、中介者模式和观察者模式"的内容了，经过本文的学习后，相信大家对什么是迭代器模式、中介者模式和观察者模式这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是，小编将为大家推送更多相关知识点的文章，欢迎关注！
