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

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

一、观察者模式

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

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

观察者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层。