[知识池]彻底了解设计模式（系列四）

今天主要分享三个常见的设计模式：观察者模式与命令模式、外观模式

一、观察者模式

定义：对象间的一对多依赖关系，每当一个对象发生改变，则所有依赖于它的对象都会得到通知并且被自动更新。类似于消息机制。它把观察者、被观察者分隔开，提高了程序的可维护性和重用性。

实现：注册 -> 通知 -> 撤销注册

观察者Observer：所有潜在的观察者必须实现观察者接口，这个接口只有update方法，当主题改变时，它会调用。

具体观察者ConcreteObserver：具体观察者可以是任何实现了Observer接口的类，观察者必须注册具体主题，一边接收更新。

可观察者Subject：主题接口，即可观察者Observable，对象调用此接口注册为观察者，或者把自己从观察者中删除，每个主题可以有多个观察者。

举个实例，老师与学生是一对多的关系，老师给学生布置作业，这个动作作为主题事件；当老师布置一道题时，就要自动通知所有学生，再布置下一道题。UML如下：

示例代码如下：

public interface Observer {    // 当主题状态改变时，会将一个String类型字符传入方法的参数，每个观察者都需要实现这个方法    void update(String info);}

观察者

public class StudentObserver implements Observer {    // 保存一个Subject的引用    private TeacherSubject t;    // 学生的名称用来标识不同的学生    private String name;    // 构造观察者    public StudentObserver(String name,TeacherSubject t){        this.name = name;        this.t = t;        // 每创建一个学生对象，默认都要添加到观察者行列里面        t.addObserver(this);    }    @Override    public void update(String info) {        System.out.println(name+"得到作业:"+info);    }}

被观察者：

public interface Subject {    // 添加观察者    void addObserver(Observer obj);    // 移除观察者    void deleteObserver(Observer obj);    // 当主题方法改变时，这个方法调用通知所有观察者    void notifyObserver();}

具体的被观察者类

public class TeacherSubject implements Subject {    //  用来存放和记录观察者    public List<Observer> observerList = new ArrayList<>();    // 记录状态的字符串    private String info;    @Override    public void addObserver(Observer obj) {        observerList.add(obj);    }    @Override    public void deleteObserver(Observer obj) {        observerList.remove(observerList.indexOf(obj));    }    @Override    public void notifyObserver() {        observerList.forEach(            item -> {                Observer o = (Observer)item;                o.update(info);            }        );    }    // 布置作业的方法，在方法最后需要调用notifyObserver方法来通知所有观察者更新状态    public void setHomework(String info){        this.info = info;        this.notifyObserver();    }}

这个对象因为是被观察，所以它的一举一动，都需要告诉那些观察者位。所以在布置作业之后需要发一个通知出去。

测试类：

public class TestObserver {    public static void main(String[] args) {        TeacherSubject teacherSubject = new TeacherSubject();        StudentObserver zhangsan = new StudentObserver("张三",teacherSubject);        StudentObserver Lisi = new StudentObserver("李四",teacherSubject);        teacherSubject.setHomework("第一题");        teacherSubject.setHomework("第2题");        teacherSubject.deleteObserver(zhangsan);        teacherSubject.setHomework("第3题");    }}

二、命令模式

意图：将一个请求封装成一个对象，从而可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。

适用场景：

 能设计一个命令队列；可以将命令计入日志；允许接收请求方决定是否要否决请求；可容易地实现对请求的撤销和重做；加进新的具体命令类不影响其他类。

举例：模拟对电视机操作有开机、关机、换台命令。得有一台电视机、一个摇控器，如下：

定义电视机（功能肯定还是电视机提供的）

//命令接收者public class Tv {    public int currentChannel =0;    public void turnOn(){        System.out.println("开机");    }    public void turnOff(){        System.out.println("关机");    }    public void changeChannel(int channel){        this.currentChannel = channel;        System.out.println("换台"+channel);    }}

定义命令执行接口

//执行命令接口public interface Command {    void execute();}

定义开机、关机

//开机命令public class CommandOn implements Command{    private Tv myTv;    public CommandOn(Tv tv){        myTv = tv;    }    @Override    public void execute() {        myTv.turnOn();    }}

public class CommandOff implements Command {    private Tv myTv;    public CommandOff(Tv tv){        this.myTv = tv;    }    @Override    public void execute() {        myTv.turnOff();    }}

遥控器

//遥控器对象public class Control {    private Command onCommand,offCommand;    public Control(Command on,Command off){        onCommand  =on;        offCommand=off;    }    public void turnOn(){        onCommand.execute();    }    public void turnOff(){        offCommand.execute();    }}

开始摇控

public class Client {    public static void main(String[] args) {        // 命令接收者        Tv myTv = new Tv();        // 开机命令        CommandOn on = new CommandOn(myTv);        // 关机        CommandOff off = new CommandOff(myTv);        Control control = new Control(on,off);        // 开机        control.turnOn();        control.turnOff();    }}

三、外观模式

外观模式，通过外观的包装，让应用程序只能看到外观对象，而看不到具体的细节，这样可以降低应用程序的复杂度，并且能够提高程序的可维护性。

解决的问题：为了降低复杂度，会将一个复杂的系统分成若干子系统，那如何做到各个系统之间的通信和相互依赖关系达到最小尼？

适用场景：

1、当你要为一个复杂子系统提供一个简单接口时。

2、客户程序与抽象类实现存在很大的依赖性，引入facade可以将这个子系统与客户以及其他子系统分离，提高子系统的独立性和可移植性

3、需要构建一个层次结构的子系统时，通过使用facade模式定义子系统中每层的入口点。

示例代码：

public class Light {    private int isOpen=0;    public void on(){        System.out.println("Light is open");        this.isOpen=1;    }    public void off(){        System.out.println("Light is off");        this.isOpen=0;    }}// 电扇public class Fan {    private int isOpen=0;    public void on(){        System.out.println("Fan is open");        this.isOpen=1;    }    public void off(){        System.out.println("Fan is off");        this.isOpen=0;    }}// 外观模式public class SwitchFacade {    private Light myLight = new Light();  // 电灯    private Fan myFan = new Fan();  // 电扇    // 晚上开电灯    public void method1(int isOpen) {        if (isOpen == 1) {            this.myFan.on();            this.myLight.on();        } else {            this.myFan.off();            this.myLight.off();        }    }    // 白天不需要电灯    public void method2(int isOpen) {        if (isOpen == 1) {            this.myFan.on();        } else {            this.myFan.off();        }    }}public class Client {    static void open(){        SwitchFacade facade = new SwitchFacade();        facade.method1(1);    }    static void close(){        SwitchFacade facade = new SwitchFacade();        facade.method1(0);    }    public static void main(String[] args) {        open();    }}

client想要调用到具体的对象的时候必须要经过一层facade层。