设计模式(七)

迭代器模式

看一个具体的需求

编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。

传统的方式的问题分析

将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的。实际上我们的要求是：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，因此这种方案，不能很好实现的遍历的操作。解决方案：=> 迭代器模式

基本介绍

迭代器模式（Iterator Pattern）是常用的设计模式，属于行为型模式。如果我们的集合元素是用不同的方式实现的，有数组，还有java的集合类，或者还有其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即：不暴露其内部的结构。

Iterator ：迭代器接口，是系统提供，含义 hasNext, next, remove
ConcreteIterator : 具体的迭代器类，管理迭代
Aggregate :一个统一的聚合接口，将客户端和具体聚合解耦
ConcreteAggregate:具体聚合类

代码实现

//具体迭代器
public class ComputeIterator implements Iterator {
    //假定计算机学院是以数组形式存放
    private Department[] departments;
    private int index = 0;

    public ComputeIterator(Department[] departments) {
        this.departments = departments;
    }

    @Override
    public boolean hasNext() {
        if(index > departments.length-1 || departments[index] == null){
            //当数组索引越界，或者数组位置为空的时候，返回false
            return false;
        }else{
            return true;
        }
    }

    @Override
    public Object next() {
        return departments[index++];
    }
}
public class InfoIterator implements Iterator {
    private List<Department> list;
    private int size = 0;

    public InfoIterator(List<Department> list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        if(size > list.size()-1){
            return false;
        }else{
            return true;
        }
    }

    @Override
    public Object next() {
        return list.get(size++);
    }
}
//集合接口
public interface College {
    String getName();
    Iterator createIterator();
    void addDepartment(Department department);
}
public class ComputeCollege implements College {
    private Department[] departments;
    private int elementOfSize = 0;

    public ComputeCollege() {
        this.departments = new Department[5];
        addDepartment(new Department("Java","Java"));
        addDepartment(new Department("PHP","PHP"));
        addDepartment(new Department("Python","Python"));
    }

    @Override
    public String getName() {
        return "计算机学院";
    }

    @Override
    public Iterator createIterator() {
        return new ComputeIterator(departments);
    }

    @Override
    public void addDepartment(Department department) {
        departments[elementOfSize] = department;
        elementOfSize++;
    }
}
public class InfoCollege implements College{
    private List<Department> list;

    public InfoCollege() {
        this.list = new ArrayList<>();
        addDepartment(new Department("信息安全","信息安全"));
        addDepartment(new Department("网络安全","网络安全"));
    }

    @Override
    public String getName() {
        return "信息学院";
    }

    @Override
    public Iterator createIterator() {
        return new InfoIterator(list);
    }

    @Override
    public void addDepartment(Department department) {
        list.add(department);
    }
}
//输出
public class Output {
    private List<College> list;

    public Output(List<College> list) {
        this.list = list;
    }
    public void print(){
        for(College c : list){
            System.out.println("----"+ c.getName() +"----");
            printDepartment(c);
        }
    }

    //输出学院专业
    private void printDepartment(College college){
        Iterator iterator = college.createIterator();
        while(iterator.hasNext()){
            Department department = (Department) iterator.next();
            System.out.println(department.getName());
        }
    }
}
//客户端
List<College> list = new ArrayList<>();
list.add(new ComputeCollege());
list.add(new InfoCollege());

Output output = new Output(list);
output.print();

迭代器在JDK中的使用

在ArrayList内部有一个内部类，Itr实现了Iterator接口，用于对ArrayList集合进行遍历，当我们调用iterator方法时候，会返回这个集合。

内部类Itr充当具体实现迭代器Iterator 的类，作为ArrayList 内部类 - List 就是充当了聚合接口，含有一个iterator() 方法，返回一个迭代器对象 - ArrayList 是实现聚合接口List 的子类，实现了iterator() - Iterator 接口系统提供 - 迭代器模式解决了不同集合(ArrayList ,LinkedList) 统一遍历问题

迭代器模式的注意事项和细节

提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以遍历对象了。
隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成。
提供了一种设计思想，就是一个类应该只有一个引起变化的原因（叫做单一责任原则）。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变的话，只影响到了迭代器。
当要展示一组相似对象，或者遍历一组相同对象时使用, 适合使用迭代器模式
每个聚合对象都要一个迭代器，会生成多个迭代器不好管理类。

观察者模式

天气预报项目需求

天气预报项目需求,具体要求如下：

1.气象站可以将每天测量到的温度，湿度，气压等等以公告的形式发布出去(比如发布到自己的网站或第三方)。
2.需要设计开放型API，便于其他第三方也能接入气象站获取数据。
3.提供温度、气压和湿度的接口
4.测量数据更新时，要能实时的通知给第三方

天气预报设计方案1-普通方案

通过getXxx方法，可以让第三方接入，并得到相关信息.
当数据有更新时，气象站通过调用dataChange() 去更新数据，当第三方再次获取时，就能得到最新数据，当然也可以推送。

代码实现

//具体观察者
public class CurrentConditions {
    private float temperature;//温度
    private float pressure;//气压
    private float humidity;//湿度

    public void update(float temperature,float pressure,float humidity){
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }

    public void display(){
        System.out.println("Today temperature: " + temperature);
        System.out.println("Today pressure: " + pressure);
        System.out.println("Today humidity: " + humidity);
    }
}
//
public class WeatherData {
    private float temperature;
    private float pressure;
    private float humidity;
    private CurrentConditions currentConditions;

    public WeatherData(CurrentConditions currentConditions) {
        this.currentConditions = currentConditions;
    }

    public float getTemperature() {
        return temperature;
    }

    public float getPressure() {
        return pressure;
    }

    public float getHumidity() {
        return humidity;
    }
    public void dataChange(){
        currentConditions.update(temperature,pressure,humidity);
    }
    public void setData(float temperature,float pressure,float humidity){
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        dataChange();
    }
}
//客户端
CurrentConditions currentConditions = new CurrentConditions();
WeatherData weatherData = new WeatherData(currentConditions);
weatherData.setData(30f,100f,30f);

观察者模式(Observer)原理

观察者模式类似订牛奶业务
奶站/气象局：Subject
用户/第三方网站：Observer

Subject：登记注册、移除和通知
registerObserver 注册
removeObserver 移除
notifyObservers() 通知所有的注册的用户，根据不同需求，可以是更新数据，让用户来取，也可能是实施推送，看具体需求定。

Observer：接收输入
观察者模式：对象之间多对一依赖观察者模式设计后，会以集合的方式来管理用户(Observer)，包括注册，移除和通知。 2) 这样，我们增加观察者(这里可以理解成一个新的公告板)，就不需要去修改核心类WeatherData不会修改代码，遵守了ocp原则。的一种设计方案，被依赖的对象为Subject，依赖的对象为Observer，Subject通知Observer变化,比如这里的奶站是Subject，是1的一方。用户时Observer，是多的一方。

观察者模式设计后，会以集合的方式来管理用户(Observer)，包括注册，移除和通知。这样，我们增加观察者(这里可以理解成一个新的公告板)，就不需要去修改核心类WeatherData不会修改代码，遵守了ocp原则。

代码实现

//观察者接口
public interface Observer {
    public void update(float temperature,float pressure,float humidity);
}
public class CurrentConditions implements Observer {
    private float temperature;//温度
    private float pressure;//气压
    private float humidity;//湿度

    @Override
    public void update(float temperature, float pressure, float humidity){
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }

    public void display(){
        System.out.println("----CurrentConditions----");
        System.out.println("Today temperature: " + temperature);
        System.out.println("Today pressure: " + pressure);
        System.out.println("Today humidity: " + humidity);
    }
}
public class Baidu implements Observer {
    private float temperature;//温度
    private float pressure;//气压
    private float humidity;//湿度
    @Override
    public void update(float temperature, float pressure, float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }
    public void display(){
        System.out.println("----百度----");
        System.out.println("Baidu temperature: " + temperature);
        System.out.println("Baidu pressure: " + pressure);
        System.out.println("Baidu humidity: " + humidity);
    }
}
public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}
public class WeatherData implements Subject {
    private float temperature;
    private float pressure;
    private float humidity;
    private ArrayList<Observer> observers;

    public void setData(float temperature,float pressure,float humidity){
        this.temperature = temperature;
        this.pressure = pressure;
        this.observers = observers;
        dataChange();
    }
    //通知更新
    public void dataChange(){
        notifyObservers();
    }
    //更新数据
    public WeatherData() {
        observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        if(observers.contains(o)){
            observers.remove(o);
        }
    }

    @Override
    public void notifyObservers() {
        for(Observer o: observers){
            o.update(temperature,pressure,humidity);
        }
    }
}
//客户端
CurrentConditions currentConditions = new CurrentConditions();
Baidu baidu = new Baidu();
WeatherData weatherData = new WeatherData();
weatherData.registerObserver(currentConditions);
weatherData.registerObserver(baidu);
System.out.println("开始更新");
weatherData.setData(30f,100f,40f);
System.out.println("----");
weatherData.removeObserver(currentConditions);
weatherData.setData(40f,110f,20f);

中介者模式

智能家庭管理问题

智能家庭项目：智能家庭包括各种设备，闹钟、咖啡机、电视机、窗帘等。主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为：闹铃响起->咖啡机开始做咖啡->窗帘自动落下->电视机开始播放。

传统方案解决智能家庭管理问题

传统的方式的问题分析

当各电器对象有多种状态改变时，相互之间的调用关系会比较复杂
各个电器对象彼此联系，你中有我，我中有你，不利于松耦合.
各个电器对象之间所传递的消息(参数)，容易混乱
当系统增加一个新的电器对象时，或者执行流程改变时，代码的可维护性、扩展性都不理想，考虑中介者模式。

中介者模式基本介绍

中介者模式（Mediator Pattern），用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式属于行为型模式，使代码易于维护。比如MVC模式，C(Controller控制器)是M（Model模型）和V（View视图）的中介者，在前后端交互时起到了中间人的作用。

代码实现

//抽象中介者
public abstract class Mediator {
    //将给同事对象，加入到集合中
    public abstract void Register(String colleagueName, Colleague colleague);
    //接收消息, 具体的同事对象发出
    public abstract void GetMessage(int stateChange, String colleagueName);
    public abstract void SendMessage();
}
public class ConcreteMediator extends Mediator {
    //集合，放入所有的同事对象
    private HashMap<String, Colleague> colleagueMap;
    private HashMap<String, String> interMap;

    public ConcreteMediator() {
        colleagueMap = new HashMap<String, Colleague>();
        interMap = new HashMap<String, String>();
    }
    @Override
    public void Register(String colleagueName, Colleague colleague) {
        colleagueMap.put(colleagueName, colleague);
        if (colleague instanceof Alarm) {
            interMap.put("Alarm", colleagueName);
        } else if (colleague instanceof CoffeeMachine) {
            interMap.put("CoffeeMachine", colleagueName);
        } else if (colleague instanceof TV) {
            interMap.put("TV", colleagueName);
        } else if (colleague instanceof Curtains) {
            interMap.put("Curtains", colleagueName);
        }
    }
    //具体中介者的核心方法
    //1. 根据得到消息，完成对应任务
    //2. 中介者在这个方法，协调各个具体的同事对象，完成任务
    @Override
    public void GetMessage(int stateChange, String colleagueName) {
        //处理闹钟发出的消息
        if (colleagueMap.get(colleagueName) instanceof Alarm) {
            if (stateChange == 0) {
                ((CoffeeMachine) (colleagueMap.get(interMap
                        .get("CoffeeMachine")))).StartCoffee();
                ((TV) (colleagueMap.get(interMap.get("TV")))).StartTv();
            } else if (stateChange == 1) {
                ((TV) (colleagueMap.get(interMap.get("TV")))).StopTv();
            }

        } else if (colleagueMap.get(colleagueName) instanceof CoffeeMachine) {
            ((Curtains) (colleagueMap.get(interMap.get("Curtains"))))
                    .UpCurtains();

        } else if (colleagueMap.get(colleagueName) instanceof TV) {//如果TV发现消息

        } else if (colleagueMap.get(colleagueName) instanceof Curtains) {
            //如果是以窗帘发出的消息，这里处理...
        }
    }

    @Override
    public void SendMessage() {

    }
}
//同事类
//同事抽象类
public abstract class Colleague {
    //聚合一个中介者
    private Mediator mediator;
    public String name;

    public Colleague(Mediator mediator, String name) {

        this.mediator = mediator;
        this.name = name;

    }

    public Mediator GetMediator() {
        return this.mediator;
    }

    public abstract void SendMessage(int stateChange);
}
public class Alarm extends Colleague {
    public Alarm(Mediator mediator, String name) {
        super(mediator, name);
        mediator.Register(name, this);
    }
    public void SendAlarm(int stateChange) {
        SendMessage(stateChange);
    }
    @Override
    public void SendMessage(int stateChange) {
        //调用的中介者对象的getMessage
        this.GetMediator().GetMessage(stateChange, this.name);
    }
}
public class CoffeeMachine extends Colleague {
    public CoffeeMachine(Mediator mediator, String name) {
        super(mediator, name);
        mediator.Register(name,this);
    }

    @Override
    public void SendMessage(int stateChange) {
        this.GetMediator().GetMessage(stateChange, this.name);
    }
    public void StartCoffee() {
        System.out.println("It's time to start coffee!");
    }

    public void FinishCoffee() {

        System.out.println("After 5 minutes!");
        System.out.println("Coffee is ok!");
        SendMessage(0);
    }
}
public class Curtains extends Colleague {
    public Curtains(Mediator mediator, String name) {
        super(mediator, name);
        mediator.Register(name,this);
    }
    public void UpCurtains() {
        System.out.println("I am holding Up Curtains!");
    }
    @Override
    public void SendMessage(int stateChange) {
        this.GetMediator().GetMessage(stateChange, this.name);
    }
}
public class TV extends Colleague {
    public TV(Mediator mediator, String name) {
        super(mediator, name);
        mediator.Register(name,this);
    }

    @Override
    public void SendMessage(int stateChange) {
        this.GetMediator().GetMessage(stateChange, this.name);
    }
    public void StartTv() {
        System.out.println("It's time to Start TV!");
    }

    public void StopTv() {
        System.out.println("Stop TV!");
    }
}
//客户端
//创建一个中介者对象
Mediator mediator = new ConcreteMediator();

//创建Alarm 并且加入到  ConcreteMediator 对象的HashMap
Alarm alarm = new Alarm(mediator, "alarm");

//创建了CoffeeMachine 对象，并  且加入到  ConcreteMediator 对象的HashMap
CoffeeMachine coffeeMachine = new CoffeeMachine(mediator,
                                                "coffeeMachine");

//创建 Curtains , 并  且加入到  ConcreteMediator 对象的HashMap
Curtains curtains = new Curtains(mediator, "curtains");
TV tV = new TV(mediator, "TV");

//让闹钟发出消息
alarm.SendAlarm(0);
coffeeMachine.FinishCoffee();
alarm.SendAlarm(1);

中介者模式的注意事项和细节

多个类相互耦合，会形成网状结构, 使用中介者模式将网状结构分离为星型结构，进行解耦
减少类间依赖，降低了耦合，符合迪米特原则
中介者承担了较多的责任，一旦中介者出现了问题，整个系统就会受到影响
如果设计不当，中介者对象本身变得过于复杂，这点在实际使用时，要特别注意

备忘录模式

游戏角色状态恢复问题

游戏角色有攻击力和防御力，在大战Boss前保存自身的状态(攻击力和防御力)，当大战Boss后攻击力和防御力下降，从备忘录对象恢复到大战前的状态。

传统的方式的问题分析

一个对象，就对应一个保存对象状态的对象，这样当我们游戏的对象很多时，不利于管理，开销也很大。传统的方式是简单地做备份，new出另外一个对象出来，再把需要备份的数据放到这个新对象，但这就暴露了对象内部的细节。解决方案： => 备忘录模式

备忘录模式基本介绍

备忘录模式（Memento Pattern)在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。可以这里理解备忘录模式：现实生活中的备忘录是用来记录某些要去做的事情，或者是记录已经达成的共同意见的事情，以防忘记了。而在软件层面，备忘录模式有着相同的含义，备忘录对象主要用来记录一个对象的某种状态，或者某些数据，当要做回退时，可以从备忘录对象里获取原来的数据进行恢复操作。备忘录模式属于行为型模式。

备忘录模式原理类图

对原理类图的说明-即 (备忘录模式的角色及职责)

originator : 对象(需要保存状态的对象)
Memento ：备忘录对象,负责保存好记录，即Originator内部状态
Caretaker: 守护者对象,负责保存多个备忘录对象，使用集合管理，提高效率
说明：如果希望保存多个originator对象的不同时间的状态，也可以，只需要HashMap 。

代码实现

public class GameRole {
    private int vit;
    private int def;

    public GameRole(int vit, int def) {
        this.vit = vit;
        this.def = def;
    }

    public int getVit() {
        return vit;
    }

    public void setVit(int vit) {
        this.vit = vit;
    }

    public int getDef() {
        return def;
    }

    public void setDef(int def) {
        this.def = def;
    }

    public Memento saveState(){
        return new Memento(def,vit);
    }

    public void recoverGameRoleFromMemento(Memento memento){
        vit = memento.getVit();
        def = memento.getDef();
    }

    public void display(){
        System.out.println("当前英雄攻击力:" + vit);
        System.out.println("当前英雄防御力:" + def);
    }
}
//备忘
//备份状态类
public class Memento {
    private int def;
    private int vit;

    public Memento(int def, int vit) {
        this.def = def;
        this.vit = vit;
    }

    public int getDef() {
        return def;
    }

    public void setDef(int def) {
        this.def = def;
    }

    public int getVit() {
        return vit;
    }

    public void setVit(int vit) {
        this.vit = vit;
    }
}
public class Caretaker {
    //当前只需要记录一次状态，使用一个属性即可
    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}
//客户端
GameRole gameRole = new GameRole(100, 100);
System.out.println("大战之前状态");
gameRole.display();
Caretaker caretaker = new Caretaker();
caretaker.setMemento(gameRole.saveState());
System.out.println("和BOSS大战");
gameRole.setDef(60);
gameRole.setVit(40);
System.out.println("大战之后状态");
gameRole.display();
System.out.println("恢复之前状态");
gameRole.recoverGameRoleFromMemento(caretaker.getMemento());
gameRole.display();

备忘录模式的注意事项和细节

给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态。
实现了信息的封装，使得用户不需要关心状态的保存细节。
如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存, 这个需要注意。
适用的应用场景：1、后悔药。 2、打游戏时的存档。 3、Windows 里的 ctri + z。 4、IE 中的后退。
数据库的事务管理。
为了节约内存，备忘录模式可以和原型模式配合使用。

posted @ 2021-11-05 17:00 无涯子wyz 阅读(43) 评论(0) 收藏举报

刷新页面返回顶部