当前位置:首页 > 开发 > 编程语言 > 设计模式 > 正文

读《研磨设计模式》-代码笔记-状态模式-State

发表于: 2012-10-07   作者:bylijinnan   来源:转载   浏览:
摘要: 声明: 本文只为方便我个人查阅和理解,详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /* 当一个对象的内在状态改变时允许改变其行为,这个对象看起来像是改变了其类 状态模式主要解决的是当控制一个对象状态的条件表达式过于复杂时的情况 把状态的判断逻辑转移到表示不同状态的一系列类中,可以把复杂的判断逻辑简化 如果在
声明:
本文只为方便我个人查阅和理解,详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/





/*

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

如果在某段代码中if-else或者switch语句过多,老鸟们常常建议说,可以采用策略模式或者状态模式来重构
在我看来,策略模式仍然需要作if-else的判断,除非需求已明确指出要采用哪个策略
但状态模式似乎更好一些

书上关于用户投票的例子,对我这样的设计模式初学者来说,还是略嫌复杂
网上有一个更简单明了的例子:
http://www.riabook.cn/doc/designpattern/StatePattern.htm

依照上面链接的例子,我写了一个简单示例:


public class StatePatternLjn {

    public static void main(String[] args) {
        SomeObject obj = new SomeObject();
        obj.change();
        obj.change();
        obj.change();
        obj.change();
    }
}

interface State {
    
    void changeState(SomeObject obj);
    
}

class SomeObject {
    
    private State state;

    public SomeObject() {
        state = new Astate();
    }
    
    public void setState(State state) {
        this.state = state;
    }
    
    public void change() {
        this.state.changeState(this);
    }
}

class Astate implements State {

    public void changeState(SomeObject obj) {
        obj.setState(new Bstate());
        System.out.println("a -> b");
    }
}

class Bstate implements State{
    
    public void changeState(SomeObject obj) {
        obj.setState(new Cstate());
        System.out.println("b -> c");
    }
}

class Cstate implements State{
    
    public void changeState(SomeObject obj) {
        obj.setState(new Astate());
        System.out.println("c -> a");
    }
}
 
 和Strategy模式有很多相似的地方,需要说明的是两者的思想都是一致的,只不过封装的东西不同:
 State模式封装的是不同的状态,而Stategy模式封装的是不同的算法
 
 */

import java.util.HashMap;
import java.util.Map;

/*
 * 考虑一个投票的应用:
 * 一个用户只能投一票,若一个用户反复投票,而且投票次数超过5,则认为是恶意刷票,撤消投票记录并取消投票资格
 * 若超过8次,则加入黑名单并禁止再使用系统
 */

interface IVoteState {
    
    /**
     * @param user  投票的用户
     * @param voteItem 投票选项
     * @param context 
     */
    public void vote(String user, String voteItem, VoteContext context);
    
}


//正常投票
class NormalVoteState implements IVoteState {

    public void vote(String user, String voteItem, VoteContext context) {
        context.getMapVoteItem().put(user, voteItem);
        System.out.println("投票成功");
    }
    
}
//重复投票
class RepeatVoteState implements IVoteState {
    
    public void vote(String user, String voteItem, VoteContext context) {
        System.out.println("请不要重复投票");
    }
    
}
//恶意投票
class SpiteVoteState implements IVoteState {
    
    public void vote(String user, String voteItem, VoteContext context) {
        context.getMapVoteItem().remove(user);
        System.out.println("你有恶意刷票行为,取消投票资格!");
    }
    
}
//黑名单
class BlackVoteState implements IVoteState {
    
    public void vote(String user, String voteItem, VoteContext context) {
        System.out.println("进入黑名单");
    }
    
}


class VoteContext {
    
    //通常会维护(持有)一个State对象
    private IVoteState state;
    //Map<用户,投票项>
    private Map<String, String> mapVoteItem = new HashMap<String, String>();
    //Map<用户,投票次数>
    private Map<String, Integer> mapVoteCount = new HashMap<String, Integer>();
    
    //在Context里面进行状态的切换
    public void vote(String user, String voteItem) {
        Integer voteCount = mapVoteCount.get(user);
        if (voteCount == null) {
            voteCount = 0;
        }
        voteCount++;
        mapVoteCount.put(user, voteCount);
        if (voteCount == 1) {
            state = new NormalVoteState();
        } else if (voteCount > 1 && voteCount < 5) {
            state = new RepeatVoteState();
        } else if (voteCount >= 5 && voteCount < 8) {
            state = new SpiteVoteState();
        } else if (voteCount >= 8) {
            state = new BlackVoteState();
        }
        
        state.vote(user, voteItem, this);
        
    }
    
    public Map<String, String> getMapVoteItem() {
        return mapVoteItem;
    }
}


/*
 * 假如我们现在有这样一个需求:投票成功的用户将获得积分奖励,那就势必要更改VoteContext的Vote方法:
   if (voteCount == 1) {
            state = new NormalVoteStateWithPrice();
    }
    ......
 * 这就是书上说的不完美的OCP体验
 */
class NormalVoteStateWithPrice extends NormalVoteState {
    
    public void vote(String user, String voteItem, VoteContext context) {
        super.vote(user, voteItem, context);
        System.out.println("奖励积分:10");
    }
}


/*
 * 上面的示例,是在Context里面进行状态的切换
 * 状态的切换也可以在状态的处理类中实现
 * 这种情况下,若有新的需求(例如新增一种状态),则可增加一个IVoteState而不必修改已有代码
 */
interface IVoteStatee {
    
    public void vote(String user, String voteItem, VoteContextt context);
    
}


//正常投票
class NormalVoteStatee implements IVoteStatee {

    public void vote(String user, String voteItem, VoteContextt context) {
        context.getMapVoteItem().put(user, voteItem);
        System.out.println("投票成功");
        //正常投票完成,维护下一个状态,同一个人再投票就重复了
        context.getMapState().put(user, new RepeatVoteStatee());
        
    }
    
}
//重复投票
class RepeatVoteStatee implements IVoteStatee {
    
    public void vote(String user, String voteItem, VoteContextt context) {
        System.out.println("请不要重复投票");
        if (context.getMapVoteCount().get(user) >= 4) {
            context.getMapState().put(user, new SpiteVoteStatee());
        }
    }
    
}
//恶意投票
class SpiteVoteStatee implements IVoteStatee {
    
    public void vote(String user, String voteItem, VoteContextt context) {
        context.getMapVoteItem().remove(user);
        System.out.println("你有恶意刷票行为,取消投票资格!");
        if (context.getMapVoteCount().get(user) >= 7) {
            context.getMapState().put(user, new BlackVoteStatee());
        }
    }
    
}
//黑名单
class BlackVoteStatee implements IVoteStatee {
    
    public void vote(String user, String voteItem, VoteContextt context) {
        System.out.println("进入黑名单");
    }
    
}


class VoteContextt {
    
    //Map<用户,本用户投票后对应的状态>
    private Map<String, IVoteStatee> mapState = new HashMap<String, IVoteStatee>();
    //Map<用户,投票项>
    private Map<String, String> mapVoteItem = new HashMap<String, String>();
    //Map<用户,投票次数>
    private Map<String, Integer> mapVoteCount = new HashMap<String, Integer>();
    
    public void vote(String user, String voteItem) {
        
        //1.投票数加1
        Integer voteCount = mapVoteCount.get(user);
        if (voteCount == null) {
            voteCount = 0;
        }
        voteCount++;
        mapVoteCount.put(user, voteCount);
        
        //2.维护状态
        IVoteStatee state = mapState.get(user);
        if (state == null) {
            state = new NormalVoteStatee();
        }
        state.vote(user, voteItem, this);
    }

    public Map<String, IVoteStatee> getMapState() {
        return mapState;
    }

    public Map<String, String> getMapVoteItem() {
        return mapVoteItem;
    }

    public Map<String, Integer> getMapVoteCount() {
        return mapVoteCount;
    }
}

//这个类是用来测试的
public class StatePattern {

    public static void main(String[] args) {
        //测试-状态切换在Context里实现
        VoteContext context = new VoteContext();
        for (int i = 0; i < 8; i++) {
            context.vote("Tom", "A");
        }
        
        System.out.println();
        
        //测试-状态切换由状态实现类切换
        VoteContextt contextt = new VoteContextt();
        for (int i = 0; i < 8; i++) {
            contextt.vote("Tom", "A");
        }
    }

}



读《研磨设计模式》-代码笔记-状态模式-State

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
写在模式学习之前 什么是设计模式:在我们进行程序设计时,逐渐形成了一些典型问题和问题的解决方案
1、状态模式:改变对象的行为 一个用来改变类的(状态的)对象。 2:问题:当你自己实现 State 模式
问题 每个人,事物在不同的状态下会有不同的表现(动作),而一个状态又会在不同表现下转移到下一个不
定义:允许一个对象在其状态改变时,改变它的行为。看起来对象似乎修改了它的类。 解决根据不同的对
定 义:当一个对象内在状态改变时允许改变其行为,这个对象看起来像是改变了其类。 状态模式主要解决
  前言:【模式总览】——————————by xingoo   模式意图   允许一个对象在内部改变它
本文出自 http://blog.csdn.net/shuangde800 基本常识: 策略模式和状态模式是双胞胎,在出生时才分开
概述 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知
概述 允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它所属的类。 意图 状态模
本文出自 http://blog.csdn.net/shuangde800 基本常识: 策略模式和状态模式是双胞胎,在出生时才分开
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号