【再探】设计模式—访问者模式、策略模式及状态模式

 访问者模式是用于访问复杂数据结构的元素，对不同的元素执行不同的操作。策略模式是对于具有多种实现的算法，在运行过程中可动态选择使用哪种具体的实现。状态模式是用于具有不同状态的对象，状态之间可以转换，且不同状态下对象的行为不同，客户端可以不必考虑其状态及转换，对所有的状态都可以执行同一的操作。

1 访问者模式

需求：需要对一个复杂数据结构进行操作，根据其不同的元素类型执行不同的操作。

1.1 访问者模式介绍

将数据结构与数据操作分离，通过定义一个访问者对象，来实现对数据结构中各个元素的访问和处理，从而达到解耦和灵活操作的目的。

图 访问者模式 UML

1.1.1 双分派

Java 是一种支持双分派的单分派语言。

单分派	调用哪个对象（多态）的方法，在运行期确定，调用对象的哪个方法，在编译期确定。
双分派	调用哪个对象（多态）的方法，在运行期确定，调用对象的哪个方法，在运行期确定。

图 单分派与双分派

访问者模式中的元素对象中的accept方法就是双分派。

public class VisitorPattern {

    public static void main(String[] args) {
        Element[] elements = {new MobilePhone(),new Ipad(),new Computer()};
        Visitor[] visitors = {new Student(),new Programmer()};
        for (Visitor visitor : visitors) {
            for (Element element : elements) {
                element.accept(visitor);
            }
        }
    }

    private interface Element {
        void accept(Visitor visitor);
    }

    private static class MobilePhone implements Element{

        @Override
        public void accept(Visitor visitor) {
            visitor.visit(this);
        }

        public void makeCall() {
            System.out.println("打电话");
        }

        public void wechat() {
            System.out.println("微信聊天");
        }

        public void playGame() {
            System.out.println("玩王者荣耀");
        }
    }

    private static class Ipad implements Element {

        @Override
        public void accept(Visitor visitor) {
            visitor.visit(this);
        }

        public void watchTv() {
            System.out.println("刷剧");
        }

        public void playGame() {
            System.out.println("玩王者荣耀,大屏更爽");
        }
    }

    private static class Computer implements Element {

        @Override
        public void accept(Visitor visitor) {
            visitor.visit(this);
        }

        public void playGame() {
            System.out.println("玩电脑游戏：使命召唤");
        }

        public void work() {
            System.out.println("用于工作");
        }
    }

    private interface Visitor {
        void visit(MobilePhone mobilePhone);
        void visit(Ipad ipad);
        void visit(Computer computer);
    }

    private static class Programmer implements Visitor {

        @Override
        public void visit(MobilePhone mobilePhone) {
            mobilePhone.makeCall();
        }

        @Override
        public void visit(Ipad ipad) {
            ipad.playGame();
        }

        @Override
        public void visit(Computer computer) {
            computer.work();
        }
    }

    private static class Student implements Visitor {

        @Override
        public void visit(MobilePhone mobilePhone) {
            mobilePhone.wechat();
        }

        @Override
        public void visit(Ipad ipad) {
            ipad.watchTv();
        }

        @Override
        public void visit(Computer computer) {
            computer.playGame();
        }
    }

}

1.2 优缺点

优点：

1. 将数据结构与数据操作分离，当需要添加新的操作时，只添加新的子类即可，符合开闭原则。
2. 将对元素的操作集中到一个类中，而不是分散在元素的子类中，使得职责更加明确，代码更加清晰，符合单一职责原则。

缺点：

1. 不适合结构不稳定的数据结构，当新增或删除元素时，需要修改访问者类，不符合开闭原则。
2. 如果访问者需要访问元素的内部信息，可能会破坏封装性。

2 策略模式

需求：一个算法有多种实现方式，或一个对象有很多的行为，这些行为需要使用多重条件选择语句来实现。期望把这些行为转移到具体的策略类中，避免使用难以维护的多重语句。

2.1 策略模式介绍

定义一个算法接口，然后将其不同的实现封装到具体的策略类中，并让它们可以相互替换。

图 策略模式 UML

public class StrategyPattern {

    public static void main(String[] args) {
        SortAlgorithm[] sortAlgorithms = {new BubbleSortAlgorithm(),new SelectionSortAlgorithm()};
        Integer[][] array = {{34,23,2,4,6,44,11,53,221,123},{3,66,27,212,45,565,11,44,33,12,465,55,22,14,56}};
        for (SortAlgorithm sortAlgorithm : sortAlgorithms) {
            for (Integer[] arr : array) {
                sortAlgorithm.sort(arr);
            }
            System.out.println();
        }
    }

    private static abstract class SortAlgorithm {
        public void sort(Integer[] array) { // 升序
            if (array != null && array.length > 1) {
                array = Arrays.copyOf(array,array.length);
                opera(array);
                System.out.println(Arrays.asList(array));
            }
        }

        protected abstract void opera(Integer[] array);
    }

    /**
     * 冒泡排序
     */
    private static class BubbleSortAlgorithm extends SortAlgorithm{
        @Override
        protected void opera(Integer[] array) {
            for (int i = 0; i < array.length; i++) {
                for (int j = i + 1; j < array.length; j++) {
                    if (array[i] > array[j]) {
                        int temp = array[j];
                        array[j] = array[i];
                        array[i] = temp;
                    }
                }
            }
        }
    }

    /**
     * 选择排序
     */
    private static class SelectionSortAlgorithm extends SortAlgorithm {
        @Override
        protected void opera(Integer[] array) {
            for (int i = 0; i < array.length; i++) {
                int minPos = i;
                for (int j = i+1; j <array.length; j++) {
                    if (array[minPos] > array[j]) {
                        minPos = j;
                    }
                }
                int temp = array[i];
                array[i] = array[minPos];
                array[minPos] = temp;
            }
        }
    }

}

2.2 优缺点

优点：

1. 符合开闭原则，增加新的算法或行为时只需要添加子类即可。
2. 避免了多重条件选择语句。

缺点：

1. 客户端必须知道所有的策略类，并自行决定使用哪个策略类。
2. 会增加类的数量。

3 状态模式

需求：系统中某个对象存在多个状态，这些状态之间可以进行转换，且对象在不同状态下的行为不同。

3.1 状态模式介绍

将一个对象的状态从该对象中分离出来，封装到专门的状态类中。对于客户端而言，无须关心对象的状态及转换，无论对象处于哪种状态，客户端都可以一致性地处理。

图 状态模式 UML

public class StatePattern {

    public static void main(String[] args) {
        BackCard backCard = new BackCard();
        backCard.save(100);
        backCard.withdraw(1000);
        backCard.withdraw(600);
        backCard.withdraw(400);
        backCard.withdraw(100);
    }

    private static class BackCard {

        private final static State[] stateList = {new NormalState(),new Overdraft(),new LimitState()};

        private State state = stateList[0];

        private double balance = 0;

        public double getBalance() {
            return balance;
        }

        public void setBalance(double balance) {
            this.balance = balance;
        }

        public void save(double money) {
            System.out.println("存钱操作:" + money);
            this.balance += money;
            changeState();
        }

        public void withdraw(double money) {
            System.out.println("取钱操作:" + money);
            try {
                state.withdraw(this,money);
            } catch (RuntimeException e) {
                System.out.println("取钱失败:" + e.getMessage());
            }
            changeState();
        }

        private void changeState() {
            System.out.println("-----余额：" + balance + "-----");
            if (balance >= 0) state = stateList[0];
            else if (balance >= -1000) state = stateList[1];
            else state = stateList[2];
        }

    }

    private interface State {
        void withdraw(BackCard backCard,double money);
    }

    private static class NormalState implements State {
        @Override
        public void withdraw(BackCard backCard,double money) {
            backCard.setBalance(backCard.getBalance() - money);
        }
    }

    private static class Overdraft implements State {
        @Override
        public void withdraw(BackCard backCard,double money) {
            if (money > 500) {
                throw new RuntimeException("卡被透支，取钱不能超过500元");
            }
            backCard.setBalance(backCard.getBalance() - money);
        }
    }

    private static class LimitState implements State {
        @Override
        public void withdraw(BackCard backCard,double money) {
            throw new RuntimeException("卡被限制，不能取钱");
        }
    }

}

3.2 优缺点

优点：

1. 客户端可以不必关心对象的状态及转换，对所有状态都可进行同一操作。
2. 将与具体状态相关的行为都封装在一个类中，符合单一职责原则，更容易扩展及维护。

缺点：

1. 状态转换无论是在环境类还是状态类中，当增加新的状态或修改转换逻辑时，都需要修改转换代码，不符合开闭原则。
2. 增加了类的个数。