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

這篇文章主要講解了“什么是迭代器模式、中介者模式和觀察者模式”，文中的講解內(nèi)容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“什么是迭代器模式、中介者模式和觀察者模式”吧！

迭代器模式

一聽這名字就很熟悉，對于java程序員來說，遍歷集合還是比較常見的操作。不用關心類型，就能夠訪問數(shù)據(jù)，用的就是迭代器模式。

Aggregate(抽象容器)： 應該由所有類實現(xiàn)的抽象類，并且科研由迭代器遍歷。類似Collection接口

Iterator(抽象迭代器)： 定義遍歷容器對象的操作以及返回對象的操作

Concrete Aggregate(具體容器)

Concrete Iterator(具體迭代器)

迭代器UML：

Aggregate：

public interface Aggregate {
    MyIterator createIterator();
}

Iterator：

public interface MyIterator {
    Object next();
    boolean hasNext();
}

Concrete Aggregate:

其中這個具體的容器內(nèi)部有個內(nèi)部類ConCreateIterator

public class ConcreteAggregate implements Aggregate{
    private String[] values;

    public ConcreteAggregate(String[] values) {
        this.values = values;
    }

    @Override
    public MyIterator createIterator() {
        return new ConcreteIterator();
    }
	
    
    //內(nèi)部類，具體的迭代器類
    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());
        }
    }
}

觀察者模式

觀察者模式定義對象間的一種一對多依賴關系，使得每當一個對象狀態(tài)發(fā)生改變時，其相關依賴對象皆得到通知并被自動更新。

Subject(主題)： 通常由類實現(xiàn)的可觀察的接口。一般有添加、刪除觀察者，以及提醒觀察者更新

Concrete Subject(具體主題)： 實現(xiàn)了主題接口，并且通知觀察者們更新

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

中介者模式

中介者模式又稱調(diào)停模式，在我們現(xiàn)實生活中也會又很多中介者的存在，房屋中介者，合同中介者，在java中的中介者模式又會是什么樣子的呢。

現(xiàn)在有個這樣的需求，moba類競技游戲一般來說有五個位置，打野，法術輸出，物理輸出，輔助，坦克。為了簡便呢，就拿三個位置來看。

法師自己可以消耗，但是也會請求支援，打野呢，除了打野怪之外也要去gank，輔助要給大家占視野，同時也要回城補狀態(tài)。

中介者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("輔助占視野");
    }

    //輔助先回城補狀態(tài)了，你們先猥瑣發(fā)育
    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();
    }
}

確實可以像我們想象的一樣，各職位互相協(xié)作，但是每次需要合作之前都需要new一下其它對象，這樣其實是很不利于松耦合的，各個類之間都相互練習在一起，牽一發(fā)而動全身 。為了降低耦合度，中介者模式就出現(xiàn)了。

中介者模式

當然需求還是上面的需求，只不過多了幾個類，抽象中介者，具體中介者，抽象同事類，具體同事類

Mediator： 抽象中定義了參與者的交互方式

Concrete Mediator

Colleague： 這是一個抽象類或接口用于定義需要調(diào)解的參與者如何進行交互

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 {
    //具體中介者類要知道自己給誰進行中介調(diào)停
    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 {
    //和具體中介者產(chǎn)生一個聯(lián)系關系
    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("打野打野");
    }
    
	//設計到別人的事情，幾個人一起合作的事情呢
    //也不用自己聯(lián)系他人，直接跟中介者說下，交給中介者來辦
    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();
    }

}

感謝各位的閱讀，以上就是“什么是迭代器模式、中介者模式和觀察者模式”的內(nèi)容了，經(jīng)過本文的學習后，相信大家對什么是迭代器模式、中介者模式和觀察者模式這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！