策略模式

其思想是针对一组算法，将每一种算法都封装到具有共同接口的独立的类中，从而是它们可以相互替换。策略模式的最大特点是使得算法可以在不影响客户端的情况下发生变化，从而改变不同的功能。

栗子

/**
 * 策略接口
 */
public interface Strategy {
    void doSomething();
}


/**
 * 策略A
 */
public class StrategyA implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("执行A方案");
    }
}

/**
 * 策略B
 */
public class StrategyB implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("执行B方案");
    }
}

/**
 * 策略模式上下文
 */
public class Context {

    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void execute(){
        this.strategy.doSomething();
    }
}

/**
 * 测试类
 */
public class Test {

    public static void main(String[] args) {
        //可灵活切换策略
        Context context = new Context(new StrategyA());
        context.execute();
    }
}

状态模式

当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。

栗子

/**
 * 状态接口
 */
public interface State {

    void show();
}

/**
 * Happy状态
 */
public class Happy implements State {
    @Override
    public void show() {
        System.out.println("恋爱了,甜甜的");
    }
}

/**
 * Sad状态
 */
public class Sad implements State {
    @Override
    public void show() {
        System.out.println("失恋了,丧丧的");
    }
}

/**
 * 状态模式上下文
 */
public class Context {

    private State state;

    public void setState(State state) {
        this.state = state;
    }

    public void execute(){
        this.state.show();
    }
}

/**
 * 测试类
 */
public class Test {

    public static void main(String[] args) {
        //随时改变状态
        Context context = new Context();
        context.setState(new Happy());
        context.execute();
        context.setState(new Sad());
        context.execute();
    }
}