DesignPattern学习------State与Strategy

状态模式(State)
定义：当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。
用途：主要解决当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化！

定义依然的让人迷惑不解！如果说，状态模式就是为了替换复杂的if...else语句的，是否会有点恍然大悟的感觉？
我现在对状态模式的理解是这样的，一个类里面有过于复杂的if...else，维护起来很不方便，如果哪里有问题了，要维护一大块代码，而如果有新的条件了，则需要修改这一大段的代码。状态模式就是为了解决这个问题的。
假设有如下一段代码。

public class Find {
    public void find(int id) {
        if (id == 1) {
            System.out.println("1");
        } else if (id == 2) {
            System.out.println("2");
        } else if (id == 3) {
            System.out.println("3");
        } else if (id == 4) {
            System.out.println("4");
        }
    }
}

如果判断里面的业务比较麻烦的话，那么这段代码就很复杂了。而如果可能需求又变了，还要判断id == 5,又要找到这段代码来修改。
看看状态模式的写法，在这里，一个判断就是一个所谓的状态，符合这个状态就执行相应的动作，否则就进入下一个状态。可以想象，每个状态都有统一的接口。

public interface State {
    public void execute(Find find,int id);
}

修改Find

public class Find {
    private State state;

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

    public Find(State state) {
        this.state = state;
    }

    public void stateFind(int id) {
        state.execute(this, id);
    }
}

再看State的子类怎么写。

public class State1 implements State{
    public void execute(Find find,int id) {
        if(id == 1){
            System.out.println("1");
        }else{
            find.setState(new State2());
            find.stateFind(id);
        }
    }
}

public class State2 implements State {
    public void execute(Find find, int id) {
        if(id == 2){
            System.out.println("2");
        }else{
            find.setState(new State3());
            find.stateFind(id);
        }
    }
}

public class State3 implements State {
    public void execute(Find find, int id) {
        if(id == 3){
            System.out.println("3");
        }else{
            find.setState(new State3());
            find.stateFind(id);
        }
    }
}

测试

public class FindTest {
    Find find;

    @Before
    public void init(){
        find = new Find(new State1());
    }

    @Test
    public void testFind() throws Exception {
        find.stateFind(3);
    }
}

如果需要修改各个状态所对应的行为，到相应的类里面就可以了。如果要添加状态，实现State接口，然后依次加上去即可。类似链表了。
缺点显而易见，类太多了。。。。

策略模式(Strategy)：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。
用途：在不同时间需要应用不同的业务规则的时候，就可以考虑使用策略模式。

这个定义，我依然理解不了（可能智商不够高 :D ）

我的理解是，就代码上而言，策略模式和状态模式区别很小。状态模式是在内部判断，而策略模式是外部传入行为，直接去执行行为，而不需要再判断状态了。

修改代码如下：

public interface State {
    public void execute();
}

public class State1 implements State {
    public void execute() {
        System.out.println("1");
    }
}

public class State2 implements State {
    public void execute() {
        System.out.println("2");
    }
}

public class State3 implements State {
    public void execute() {
        System.out.println("3");
    }
}

public class Find {
    private State state;

    public Find(State state) {
        this.state = state;
    }

    public void stateFind() {
        state.execute();
    }
｝

测试

public class FindTest {
    Find find;

    @Before
    public void init(){

    }

    @Test
    public void testTotal(){
        find = new Find(new State1());
        find.stateFind();
        find = new Find(new State2());
        find.stateFind();
        find = new Find(new State3());
        find.stateFind();
    }
}

刚开始好好研究模式，欢迎拍砖！