【设计模式学习笔记】 之 状态模式

简介：

每种事物都有不同的状态，不同的状态会有不同的表现，通过更改状态从而改变表现的设计模式称为状态模式（state pattern）

下边会通过多个例子进行讲述，会有一些代码重用的类，请注意包名！

举例1：

人有多种心情，不同的心情会有不同的表现，这里先使用分支判断写个小例子

创建一个Person类，它持有一个表示心情的字符串，通过设置这个字符串并对这个字符串进行判断来决定产生不同的行为

package com.mi.state.state1;

/**
 * 人类，拥有一个状态属性
 * 这里使用分支判断演示
 * @author hellxz
 */
public class Person {
    
    private String mood = "happy";//心情 default happy
    
    //表现方法，在不同的状态下需要不同的表现
    public void perform() {
        if(mood.equals("happy")) {
            System.out.println("今天很开心，大家都到我家喝酒去吧");
        }else if(mood.equals("sad")) {
            System.out.println("今天很伤心，走，一起去喝酒");
        }else if(mood.equals("boring")) {
            System.out.println("今天很无聊，敲会代码吧");
        }
    }

    //getters & setters
    public String getMood() {
        return mood;
    }

    public void setMood(String mood) {
        this.mood = mood;
    }
    
}

测试类：

package com.mi.state.state1;

public class Test {

    public static void main(String[] args) {
        Person person = new Person();
        person.setMood("boring");
        person.perform();
    }

}

输出：

今天很无聊，敲会代码吧

这个例子的确实现了修改不同的状态而改变行为，但是代码写的不够灵活，如果添加了新的状态的时候，还需要修改大量的代码，改进版如下：

举例2：

定义Mood接口，所有心情都需要实现这个接口，Person中持有这个接口，通过set这个接口的实现类对象，来多态调用实际的perform方法

package com.mi.state.state2;

/**
 * 心情接口（使用状态模式）
 * @author hellxz
 */
public interface Mood {

    void perform(); //表现方法
}

实现Mood接口的类，每个实现类的表现方法实现都不同

package com.mi.state.state2;

/**
 * 开心的心情
 * @author hellxz
 */
public class HappyMood implements Mood {

    @Override
    public void perform() {
        System.out.println("心情不错出去钓鱼");
    }

}

package com.mi.state.state2;

/**
 * 无聊
 * @author hellxz
 */
public class BoringMood implements Mood {

    @Override
    public void perform() {
        System.out.println("好无聊啊，还是代码有意思！");
    }

}

package com.mi.state.state2;

/**
 * 心情不好
 * @author hellxz
 */
public class BadMood implements Mood {

    @Override
    public void perform() {
        System.out.println("心情不好，说好的幸福呢");
    }

}

改进后的Person类

package com.mi.state.state2;

public class Person {

    private Mood mood; //持有心情接口引用
    
    //表现方法
    public void perform() {
        //接口引用执行接口方法，多态调用实现类方法
        mood.perform();
    }

    //setters & getters
    public Mood getMood() {
        return mood;
    }

    public void setMood(Mood mood) {
        this.mood = mood;
    }
    
}

测试类

package com.mi.state.state2;

public class Test {

    public static void main(String[] args) {
        Person person = new Person();
        Mood mood = new BoringMood();
//        Mood mood = new HappyMood();
//        Mood mood = new SadMood();
        person.setMood(mood);
        person.perform();
    }
}

输出

好无聊啊，还是代码有意思！

尝试其余注释行执行的不同效果，可以发现这样实现非常灵活，只需要实现Mood接口，在测试类中传入就可以改变执行效果！细心的你可能会发现，这种结构不是策略模式的结构么？这个文章结尾会写

举例3：

人应该拥有喜悦、哀伤、无聊等状态，这些状态会在特定的时候展示出来，所以Person这个类中应该持有一个状态的集合，通过不同的传入参数来决定它的表现效果。举例2中设置Mood实现类的时候需要手动去修改Test类的代码，如果在生产环境中，我们需要改完代码、重新编译、重新部署，很麻烦，这个例子使用了配置文件 

package com.mi.state.state3;

import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import com.mi.state.state2.HappyMood;
import com.mi.state.state2.Mood;

/**
 * 状态模式中，通过配置文件获取状态，使状态更改更加灵活 本示例中引用state2包中的大部分代码，除了Person类和测试类
 * 
 * @author hellxz
 */
public class Person {

    // 人对象内部持有心情属性，在特定场景触发，所以应持有所有心情属性集合
    // 方便的情况下，可以使用其他数据结构
    private Map<String, Mood> moods = new HashMap<>();

    // 构造方法
    public Person() {
        // 添加默认心情属性，防止配置文件出错而导致的空指针问题
        moods.put("default", new HappyMood());
    }

    // 添加心情属性
    public void addMood(String moodName, Mood mood) {
        moods.put(moodName, mood);
    }

    // 人的表现方法
    public void perform() throws IOException {
        // 心情map中获取配置文件中的key所对应的对象，在方法中声明变量，避免多线程安全问题
        Mood currentMood = moods.get(getMoodName());
        // 防止出现空指针，设置默认心情
        if (currentMood == null) {
            currentMood = moods.get("default");
        }
        // 当前心情表现
        currentMood.perform();
    }

    // 私有方法，配置文件中读取moodName
    private String getMoodName() throws IOException {
        // 读取配置文件
        Properties props = new Properties();
        props.load(Person.class.getResourceAsStream("state.properties"));
        return props.getProperty("mood");
    }

    // 这个方法是为了批量添加心情集合，为什么我们不用Map作为传入的参数呢？
    // 我们最好不要暴露内部的结构，更加专业，而且因为客户端程序员不知道内部数据结构，
    // 这时可以接收其他集合对象
    @SuppressWarnings("unchecked")
    public void addAllMoods(Collection<Mood> moods) {
        ((Collection<Mood>) this.moods).addAll(moods);
    }
}

 测试类：

package com.mi.state.state3;

import java.io.IOException;

import com.mi.state.state2.BadMood;
import com.mi.state.state2.BoringMood;
import com.mi.state.state2.HappyMood;

/**
 * 测试类
 * @author hellxz
 */
public class Test {

    public static void main(String[] args) throws IOException {
        Person person = new Person();
        person.addMood("happy", new HappyMood());
        person.addMood("bad", new BadMood());
        person.addMood("boring", new BoringMood());
        
        person.perform();
    }

}

配置文件state.properties：

mood=bad

输出：

心情不好，说好的幸福呢

配置文件中填入不同value，测试效果，如果该值未在Mood实现类中定义，那么会使用默认的happy状态。

举例4：

人有青少年、壮年、老年三个状态，过完一个状态之后会自动进入下一个状态，我们不能在人这个类中进行分支判断，那样代码实在是很糟糕，不灵活。这时我们需要抽取状态接口，状态有一个表现方法，还有一个获取下一状态的方法，这样我们只需要在实现类中指定下一状态为什么即可解决分支判断的窘境。

创建一个State接口

package com.mi.state.state4;

/**
 * 状态接口
 * @author hellxz
 */
public interface State {

    //表现
    public void perform();
    //下一状态
    public State nextState();
}

实现State接口的青少年、年轻人、老年

package com.mi.state.state4;

/**
 * 青少年状态
 * @author hellxz
 */
public class TeenState implements State{

    @Override
    public void perform() {
        System.out.println("我是小孩子，好好学习天天向上");
    }

    @Override
    public State nextState() {
        //下一状态为年轻人状态
        return new YouthState();
    }

}

package com.mi.state.state4;

/**
 * 年轻人状态
 * @author hellxz
 */
public class YouthState implements State{

    @Override
    public void perform() {
        System.out.println("我是年轻人，精力充沛，世界等着我去创造");
    }

    @Override
    public State nextState() {
        //年轻人下一状态为老年人状态
        return new EldState();
    }

}

package com.mi.state.state4;

/**
 * 老年状态
 * @author hellxz
 */
public class EldState implements State {

    @Override
    public void perform() {
        System.out.println("我是老年人，一起来跳老年迪斯科");
    }

    @Override
    public State nextState() {
        //老年之后没有了，这里组成一个环形
        return new TeenState();
    }

}

新建Person类

package com.mi.state.state4;

/**
 * 人类，状态分别为 青少年，年轻人，老年
 * 
 * @author hellxz
 */
public class Person {

    //状态接口引用
    private State state;

    public void setState(State state) {
        this.state = state;
    }
    
    //表现
    public void perform() {
        state.perform();
        //更改状态为下一状态
        state = state.nextState();
    }
}

测试类，多次执行perform方法

package com.mi.state.state4;

public class Test {

    public static void main(String[] args) {
        
        Person person = new Person();
        person.setState(new TeenState());
        person.perform();
        person.perform();
        person.perform();
        person.perform();
    }

}

输出：

我是小孩子，好好学习天天向上
我是年轻人，精力充沛，世界等着我去创造
我是老年人，一起来跳广场舞
我是小孩子，好好学习天天向上

这样的确实现了自动转换下一状态的功能，但是看过编程思想我们知道，java的垃圾回收器不是很勤奋的，我们每次执行nextState方法就会new一个对象，这样可能会造成内存负载过高，这样就有了柳大讲的使用枚举方法实现的状态模式，也就是这个例子的升级版

举例5：

使用枚举方式实现人的青少年、年轻人、老年状态的自动切换，解决执行举例3中的nextState方法new过多的对象问题

这里复制举例4的Person类到新包中，为什么不引用呢？因为之前的例子中已经指向了同包中的State接口，如果引用过来，我们setState会报错

package com.mi.state.state5;

/**
 * 人类，状态分别为 青少年，年轻人，老年
 * 
 * @author hellxz
 */
public class Person {

    //状态接口引用
    private State state;

    public void setState(State state) {
        this.state = state;
    }
    
    //表现
    public void perform() {
        state.perform();
        //更改状态为下一状态
        state = state.nextState();
    }
}

枚举实现的State

package com.mi.state.state5;

/**
 * 枚举实现状态模式，内部的变量均为匿名内部类实现
 * 
 * @author hellxz
 */
public enum State {

    TEEN {
        @Override
        public void perform() {
            System.out.println("我是小孩子，好好学习天天向上");
        }

        @Override
        public State nextState() {
            return YOUTH;
        }
    },
    YOUTH {
        @Override
        public void perform() {
            System.out.println("我是年轻人，精力充沛，世界等着我去创造");
        }

        @Override
        public State nextState() {
            return ELD;
        }
    },
    ELD {
        @Override
        public void perform() {
            System.out.println("我是老年人，一起来跳老年迪斯科");
        }

        @Override
        public State nextState() {
            return TEEN;
        }
    };

    public abstract void perform(); //表现

    public abstract State nextState(); //下一状态
}

测试类，因为是枚举，所以类名.元素 表示实现了State接口的对象

package com.mi.state.state5;

public class Test {

    public static void main(String[] args) {
        
        Person person = new Person();
        person.setState(State.TEEN);
        person.perform();
        person.perform();
        person.perform();
        person.perform();
    }

}

输出：

我是小孩子，好好学习天天向上
我是年轻人，精力充沛，世界等着我去创造
我是老年人，一起来跳广场舞
我是小孩子，好好学习天天向上

总结：

1. 表示每种事物中根据不同状态拥有的不同表现
2. 拥有和策略模式相同的结构，同样是持有一个接口引用，使用这个接口引用来执行方法。
3. 根据set方式设置具体实现类

状态模式和策略模式的区别：

• 相同点： 相同的代码结构
• 不同点：语义不同。

状态模式中的状态接口必须是这种事物紧密相关的，即只有有这种事物才会有这种状态，互相依存；而策略模式中的被执行体的接口是可以单独存在的，与代码执行的这个类之间耦合不大。比如策略模式中的cd举例，cd是一个接口，它可以单独存在，也可以和其他的播放设备发生关联。而这篇博客中的Person和State之间的关系就是互相依存的关系，状态不能单独存在。

有些时候策略模式和状态模式是含糊不清的，比如京东打折，工作日9折，周末8折，这个时候我们既可以说工作日、周末是不同的状态，也可以说不同的时间使用不同的策略