这篇文章主要讲解了“什么是迭代器模式、中介者模式和观察者模式”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“什么是迭代器模式、中介者模式和观察者模式”吧！
公司主营业务：成都做网站、网站制作、移动网站开发等业务。帮助企业客户真正实现互联网宣传，提高企业的竞争能力。成都创新互联公司是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化，感谢他们对我们的高要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。成都创新互联公司推出监利免费做网站回馈大家。
一听这名字就很熟悉，对于java程序员来说，遍历集合还是比较常见的操作。不用关心类型，就能够访问数据，用的就是迭代器模式。
Aggregate(抽象容器)：应该由所有类实现的抽象类，并且科研由迭代器遍历。类似Collection接口
Iterator(抽象迭代器)：定义遍历容器对象的操作以及返回对象的操作
Concrete Aggregate(具体容器)
Concrete Iterator(具体迭代器)
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
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，辅助要给大家占视野，同时也要回城补状态。
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();
}
}感谢各位的阅读，以上就是“什么是迭代器模式、中介者模式和观察者模式”的内容了，经过本文的学习后，相信大家对什么是迭代器模式、中介者模式和观察者模式这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是创新互联，小编将为大家推送更多相关知识点的文章，欢迎关注！
