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

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

package com.zzk.test.strategy.template;import com.zzk.test.strategy.template.base.Strategy;/*** @描述 环境角色*/
public class Context {/*** 策略对象*/private Strategy strategy;/*** @param strategy 具体策略对象*/public Context(Strategy strategy) {this.strategy = strategy;}/*** @描述 执行策略方法*/public void contextInterface() {strategy.strategyInterface();}
}

package com.zzk.test.strategy.template.base;/*** @描述 抽象策略角色*/
public interface Strategy {/*** @描述 策略方法*/void strategyInterface();
}

package com.zzk.test.strategy.template;import com.zzk.test.strategy.template.base.Strategy;/*** @描述 具体策略类A*/
public class ConcreteStrategyA implements Strategy {@Overridepublic void strategyInterface() {// TODO Auto-generated method stub
    }
}

package com.zzk.test.strategy.template;import com.zzk.test.strategy.template.base.Strategy;/*** @描述 具体策略类B*/
public class ConcreteStrategyB implements Strategy {@Overridepublic void strategyInterface() {// TODO Auto-generated method stub
    }
}

package com.zzk.test.strategy.template;import com.zzk.test.strategy.template.base.Strategy;/*** @描述 具体策略类C*/
public class ConcreteStrategyC implements Strategy {@Overridepublic void strategyInterface() {// TODO Auto-generated method stub
    }
}

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

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

package xyz.zeling.test.state.template.base;/*** @description 抽象状态角色* @author zeling* @date 2018年1月14日 下午8:41:14*/
public interface State {/*** @description 处理方法* @date 2018年1月14日 下午8:41:00*/void handle();
}

package xyz.zeling.test.state.template;import xyz.zeling.test.state.template.base.State;/*** @description 具体状态类A* @author zeling* @date 2018年1月14日 下午8:45:00*/
public class ConcreteStateA implements State {@Overridepublic void handle() {// TODO Auto-generated method stub
    }
}

package xyz.zeling.test.state.template;import xyz.zeling.test.state.template.base.State;/*** @description 具体状态类A* @author zeling* @date 2018年1月14日 下午8:45:00*/
public class ConcreteStateB implements State {@Overridepublic void handle() {// TODO Auto-generated method stub
    }
}

package xyz.zeling.test.state.template;import xyz.zeling.test.state.template.base.State;/*** @description 具体状态类A* @author zeling* @date 2018年1月14日 下午8:45:00*/
public class ConcreteStateC implements State {@Overridepublic void handle() {// TODO Auto-generated method stub
    }
}

package xyz.zeling.test.state.template;import xyz.zeling.test.state.template.base.State;/*** @description 状态模式，环境角色类* @author zeling* @date 2018年1月14日 下午8:43:58*/
public class Context {/*** 状态对象*/private State state;/*** @description 设置状态* @date 2018年1月14日 下午9:13:20* @param state 具体状态*/public void setState(State state) {this.state = state;}/*** @description 执行策略方法* @date 2018年1月14日 下午8:43:31*/public void request() {state.handle();}
}

    /*** @description 使用状态模式：状态模式，又称状态对象模式（Pattern of Objects for*              States），状态模式是对象的行为模式。状态模式允许一个对象在其内部状态改变的时候改变其行为。这个对象看上去就像是改变了它的类一样* @date 2018年1月14日 下午4:04:16*/public static void useState() {// 具体使用状态State state = new ConcreteStateA();// 创建环境Context context = new Context();// 设置状态并执行
        context.setState(state);context.print();}

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