网站建设资讯

NEWS

网站建设资讯

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

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

公司主营业务:成都做网站、网站制作、移动网站开发等业务。帮助企业客户真正实现互联网宣传,提高企业的竞争能力。成都创新互联公司是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化,感谢他们对我们的高要求,感谢他们从不同领域给我们带来的挑战,让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。成都创新互联公司推出监利免费做网站回馈大家。

迭代器模式

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

}

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


当前标题:什么是迭代器模式、中介者模式和观察者模式
转载来于:http://cdweb.net/article/pjcpgh.html