Java设计模式-策略模式、状态模式

前言

当代码中出现多重if-else语句或者switch语句时,

弊端有二：弊端之一：如果这样的代码出现在多处，那么一旦出现需求变更，就需要把所有地方的if-else或者switch代码进行更改，要是遗漏了某一处，那么程序就会出错。弊端之二：代码逻辑难以理解。

卫语句

卫语句的使用，并不能改变前言说的弊端：一旦需求更改，需要修改所有使用更改需求的if-else代码块。不过使用卫语句可以让自己或者代码维护人员很容易的了解代码的含义。

代替异常分支

所谓的异常分支就是普通情况之外的分支，这种情况的下的if-else可以用以下代替。

if (condition)
    return obj;

代替多重if-else分支

这个情况的代替方式是可以为

if (isSunshine()) {
    // 晴天时处理逻辑
}
if (isRain()) {
    // 下雨时处理逻辑
}
if (isOvercast()) {
    // 阴天时处理逻辑
}
...

策略模式

使用策略模式可以代替多重if-else和switch语句，让代码维护变得更加简单。 
策略模式UML： 

• 环境(Context)角色：持有一个Strategy的引用
• 抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现
• 具体策略(ConcreteStrategy)角色：包装了相关的算法或行为

策略模式代码模板：

/**
 * @description 环境角色
 */
public class Context {

    /**
     * 策略对象
     */
    private Strategy strategy;

    /**
     * @param strategy 具体策略对象
     */
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    /**
     * @description 执行策略方法
     */
    public void contextInterface() {
        strategy.strategyInterface();
    }
}

/**
 * @description 抽象策略角色
 */
public interface Strategy {

    /**
     * @description 策略方法
     */
    void strategyInterface();
}

/**
 * @description 具体策略类A
 */
public class ConcreteStrategyA implements Strategy {

    @Override
    public void strategyInterface() {
        // TODO Auto-generated method stub
    }
}

/**
 * @description 具体策略类B
 */
public class ConcreteStrategyB implements Strategy {

    @Override
    public void strategyInterface() {
        // TODO Auto-generated method stub
    }
}

/**
 * @description 具体策略类C
 */
public class ConcreteStrategyC implements Strategy {

    @Override
    public void strategyInterface() {
        // TODO Auto-generated method stub
    }
}

实例应用：水果有不同种类，每种水果对应不同价格，用策略模式实现。

/**
 * @description 抽象策略，水果接口
 */
public interface Fruit {
    /**
     * @description 输出对应价格
     */
    void price();
}

/**
 * @description 具体策略，苹果类
 */
public class Apple implements Fruit {

    @Override
    public void price() {
        System.out.println("苹果的价格！");
    }
}

 

/**
 * @description 具体策略，香蕉
 */
public class Banana implements Fruit {

    @Override
    public void price() {
        System.out.println("香蕉的价格！");
    }
}

/**
 * @description 具体策略，梨
 */
public class Pear implements Fruit {

    @Override
    public void price() {
        System.out.println("梨的价格！");
    }
}

 

/**
 * @description 策略环境，输出水果价格
 */
public class FruitPrice {

    /**
     * 策略对象
     */
    private Fruit fruit;

    /**
     * @param fruit 策略对象
     */
    public FruitPrice(Fruit fruit) {
        this.fruit = fruit;
    }

    /**
     * @description 输出水果价格
     */
    public void printFruitPrice() {
        fruit.price();
    }
}

客户端

    /**
     * @description 使用策略模式:针对一组算法，将每一个算法封装到具有共同接口的独立的类
     */
    public static void useStrategy() {
        // 具体使用策略
        Fruit apple = new Apple();
        // 将策略放入环境中并执行策略
        new FruitPrice(apple).printFruitPrice();
    }

状态模式

状态模式类图： 

说明：

• 环境(Context)角色，也成上下文：定义客户端所感兴趣的接口，并且保留一个具体状态类的实例。这个具体状态类的实例给出此环境对象的现有状态
• 抽象状态(State)角色：定义一个接口，用以封装环境（Context）对象的一个特定的状态所对应的行为
• 具体状态(ConcreteState)角色：每一个具体状态类都实现了环境（Context）的一个状态所对应的行为

策略模式代码模板：

/**
 * @description 抽象状态角色
 */
public interface State {

    /**
     * @description 处理方法
     */
    void handle();
}

 

/**
 * @description 具体状态类A
 */
public class ConcreteStateA implements State {

    @Override
    public void handle() {
        // TODO Auto-generated method stub
    }
}

 

/**
 * @description 具体状态类B
 */
public class ConcreteStateB implements State {

    @Override
    public void handle() {
        // TODO Auto-generated method stub
    }
}

 

/**
 * @description 具体状态类C
 */
public class ConcreteStateC implements State {

    @Override
    public void handle() {
        // TODO Auto-generated method stub
    }
}

 

/**
 * @description 状态模式，环境角色类
 */
public class Context {

    /**
     * 状态对象
     */
    private State state;

    /**
     * @description 设置状态
     * @param state 具体状态
     */
    public void setState(State state) {
        this.state = state;
    }

    /**
     * @description 执行策略方法
     */
    public void request() {
        state.handle();
    }
}

实例应用：橘子有不同颜色，状态不同的橘子颜色不同，用状态模式实现。

/**
 * @description 状态模式，状态接口
 */
public interface Orange {
    /**
     * @description 输出橘子的颜色
     */
    void printColor();
}

 

/**
 * @description 状态2：青色的橘子
 */
public class CyanOrange implements Orange {

    @Override
    public void printColor() {
        System.out.println("My color is cyan!");
    }
}

 

/**
 * @description 橘子状态管理器
 */
public class OrangeStateManage {

    /**
     * 橘子的状态
     */
    private Orange state;

    /**
     * @description 设置橘子的状态
     * @param state
     */
    public void setState(Orange state) {
        this.state = state;
    }

    /**
     * @description 输出当前状态的橘子颜色
     */
    public void print() {
        state.printColor();
    }
}

/**
 * @description 状态1：红色外观的橘子
 */
public class RedOrange implements Orange {

    @Override
    public void printColor() {
        System.out.println("My color is red!");
    }
}

/**
 * @description 状态3：黄色的橘子
 */
public class YellowOrange implements Orange {

    @Override
    public void printColor() {
        System.out.println("My color is yellow!");
    }
}

客户端

    /**
     * @description 使用状态模式：状态模式，又称状态对象模式（Pattern of Objects for
     *              States），状态模式是对象的行为模式。状态模式允许一个对象在其内部状态改变的时候改变其行为。这个对象看上去就像是改变了它的类一样
     */
    public static void useState() {
        // 具体使用状态
        Orange cyanOrange = new CyanOrange();
        // 创建环境
        OrangeStateManage orangeStateManage = new OrangeStateManage();
        // 设置状态并执行
        orangeStateManage.setState(cyanOrange);
        orangeStateManage.print();
    }

策略模式和状态模式的比较

讲真，我觉得它们都差不多啊，好难区别啊！！！ 
不过，虽然讲不出来它们的区别是什么，但是有个例子可以很好的描述它们的区别

• 状态模式：这个模式就好比员工申请离职单的流程，离职单到直接上级，这个状态就是直接上级批示，等直接上级审阅之后，通过了就到下一个状态。这一个个状态对应不同的处理，这是有顺序要求的。
• 策略模式：这个模式好比于你假期要出国游玩，有日本、美国、新加坡等国家，你每到一个国家就执行不同的游玩策略，可以先去日本，也可以先去美国，没有顺序要求。