什么是迭代器模式、中介者模式和观察者模式

这篇文章主要讲解了“什么是迭代器模式、中介者模式和观察者模式”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“什么是迭代器模式、中介者模式和观察者模式”吧！

迭代器模式

一听这名字就很熟悉，对于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<Observer> 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();
    }

}

感谢各位的阅读，以上就是“什么是迭代器模式、中介者模式和观察者模式”的内容了，经过本文的学习后，相信大家对什么是迭代器模式、中介者模式和观察者模式这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是亿速云，小编将为大家推送更多相关知识点的文章，欢迎关注！