头图

每天5分钟-行为型模式(二)

cutey_none

迭代器模式

一听这名字就很熟悉,对于java程序员来说,遍历集合还是比较常见的操作。不用关心类型,就能够访问数据,用的就是迭代器模式。

Aggregate(抽象容器): 应该由所有类实现的抽象类,并且科研由迭代器遍历。类似Collection接口

Iterator(抽象迭代器): 定义遍历容器对象的操作以及返回对象的操作

Concrete Aggregate(具体容器)

Concrete Iterator(具体迭代器)

迭代器UML:

image-20210428180448060

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:

image-20210428211702974

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();
    }

}

点赞了吗

阅读 184
3 声望
0 粉丝
0 条评论
你知道吗?

3 声望
0 粉丝
宣传栏