大橙子网站建设,新征程启航
为企业提供网站建设、域名注册、服务器等服务
这篇文章主要讲解了“什么是迭代器模式、中介者模式和观察者模式”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“什么是迭代器模式、中介者模式和观察者模式”吧!
公司主营业务:成都做网站、网站制作、移动网站开发等业务。帮助企业客户真正实现互联网宣传,提高企业的竞争能力。成都创新互联公司是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化,感谢他们对我们的高要求,感谢他们从不同领域给我们带来的挑战,让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。成都创新互联公司推出监利免费做网站回馈大家。
一听这名字就很熟悉,对于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 { Listsubscribers = 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(); } }
感谢各位的阅读,以上就是“什么是迭代器模式、中介者模式和观察者模式”的内容了,经过本文的学习后,相信大家对什么是迭代器模式、中介者模式和观察者模式这一问题有了更深刻的体会,具体使用情况还需要大家实践验证。这里是创新互联,小编将为大家推送更多相关知识点的文章,欢迎关注!