Java设计模式之策略模式与状态模式

系统中用到了策略模式，如果 20180901之前的话，用一个统计策略，之后又用一个统计策略。

于是自己搞了一个策略模式：  

一、策略模式定义

定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使他们之间可以相互替换，策略模式可以在不影响客户端的情况下发生变化。

好了，定义看看就完了，我知道你很烦看定义。

二、解决场景：

某个功能有多个方案可以实现，要达到某个目的，需要根据具体的实际情况，选择合适的方法，

三、如何实现：

  分为两个层次
　(a) 环境类 
　环境类负责接收用户的请求，并根据实际情况把相应的请求委托给一组策略类中的一个；

　(b) 一组策略类
　　一组封装了具体的实现类的算法，并负责具体的计算过程  

三、策略模式优缺点

优点

策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把公共的代码移到父类里面，从而避免代码重复。使用策略模式可以避免使用多重条件(if-else)语句。多重条件语句不易维护，它把采取哪一种算法让子类实现

缺点

通过上面Demo我们会发现调用者必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类并且由于策略模式把每个具体的策略实现都单独封装成为类，如果备选的策略很多的话，那么对象的数目就会很可观。

四、策略模式使用举例  

我们写一个简单的Demo来对策略模式进行更深的理解，我们模拟游戏中玩家参与一个活动购买金币，普通玩家没有折扣，高级玩家9折优惠，VIP玩家7折优惠。

首先我们定义一个接口，这就是抽象策略角色，如下： 

public interface GameStrategy {
 
     public void goldCoin();
 
}

很简单，就是一个接口。

接下来我们编写具体策略角色类，从需求就能明白，需要有三个具体策略角色类，也就是三个策略对应不同等级玩家。

普通玩家策略类： 

public class normalStrategy implements GameStrategy {   
                                                        
    @Override                                           
    public void goldCoin() {                            
        //                                              
        System.out.println("普通玩家没有折扣");                 
    }                                                   
}                                                   

 

高级玩家策略类： 

public class advancedStrategy implements GameStrategy {

    @Override
    public void goldCoin() {
        // TODO Auto-generated method stub
        System.out.println("高级会员9折优惠");
    }
}

 

VIP玩家策略类： 

public class vipStrategy implements GameStrategy {     
                                                       
    @Override                                          
    public void goldCoin() {                           
        //                                             
        System.out.println("VIP会员7折优惠");               
    }                                                  
}                                                      

 

都很简单，就是简单打印信息。

然后编写环境角色类，如下： 

public class Context {                                
　　//持有一个Strategy的引用                                   
    private GameStrategy mGameStrategy;               
                                                      
    // 构造函数                                           
    public Context(GameStrategy strategy) {           
        this.mGameStrategy = strategy;                
    }                                                 
                                                      
    public void setStrategy(GameStrategy strategy) {  
        this.mGameStrategy = strategy;                
    }                                                 
                                                      
    public void goldCoin() {                          
        this.mGameStrategy.goldCoin();                
    }                                                 
}                                                     

 

最后就是调用了，根据不同情况调用不同策略： 

public class main {                                          
                                                             
    public static void main(String[] args) {                 
        //普通玩家策略                                             
        Context context = new Context(new normalStrategy()); 
        context.goldCoin();                                  
        //高级玩家策略                                             
        context.setStrategy(new advancedStrategy());         
        context.goldCoin();                                  
        //高级玩家策略                                             
        context.setStrategy(new vipStrategy());              
        context.goldCoin();                                  
    }                                                        
}                                                            

 

不同情况下我们替换为对应策略就可以了。

 

好了上面就是策略模式的介绍了，关键是自己慢慢理解。接下来我们了解一下状态模式。

五、状态模式定义

当一个对象在其内部状态改变的时候改变其行为。这个对象看上去就像是改变了它的类一样。又称状态对象模式，状态模式是对象的行为模式。

简单的理解就是一个类其状态改变了，那么其功能也相应的改变了。比如水变为冰，状态改变了，其功能也发生了相应变化。

六、状态模式角色

● Context（环境类）：环境类又称为上下文类，它是拥有多种状态的对象。由于环境类的状态存在多样性且在不同状态下对象的行为有所不同，因此将状态独立出去形成单独的状态类。在环境类中维护一个抽象状态类State的实例，这个实例定义当前状态，在具体实现时，它是一个State子类的对象。

● State（抽象状态类）：它用于定义一个接口以封装与环境类的一个特定状态相关的行为，在抽象状态类中声明了各种不同状态对应的方法，而在其子类中实现类这些方法，由于不同状态下对象的行为可能不同，因此在不同子类中方法的实现可能存在不同，相同的方法可以写在抽象状态类中。

● ConcreteState（具体状态类）：它是抽象状态类的子类，每一个子类实现一个与环境类的一个状态相关的行为，每一个具体状态类对应环境的一个具体状态，不同的具体状态类其行为有所不同。

七、状态模式使用举例

接下来我们编写一个小Demo来进行更深入理解：在办公系统中，一个文件会有不同状态：未处理，正在处理，已经处理。我们就简单模拟一下文件状态的切换。

首先我们看下抽象状态类，很简单就是定义一个接口： 

public interface State { 
                         
    void fileState();    
}                        

 

接下来看下三个具体状态类：

未处理状态类 

public class NotDealState  implements State{   
                                               
    @Override                                  
    public void fileState() {                  
        // TODO Auto-generated method stub     
        System.out.println("文件未处理状态");         
    }                                          
}                                              

 

正在处理状态类： 

public class DealingState implements State{  
                                             
    @Override                                
    public void fileState() {                
        // TODO Auto-generated method stub   
        System.out.println("文件正在处理状态");      
    }                                        
}                                            

 

已经处理状态类 

public class HasDealState implements State{    
                                               
    @Override                                  
    public void fileState() {                  
        // TODO Auto-generated method stub     
        System.out.println("文件已经处理状态");        
    }                                          
}                                              

 

是不是很简单，同样也只是打印一些简单的信息罢了。

然后看下上下文类： 

public class FileContext {                        
                                                  
    //默认情况下未处理状态                                  
    private State fileState = new NotDealState(); 
                                                  
    /**                                           
     * 文件状态切换为未处理状态                               
     */                                           
    public void notDeal(){                        
                                                  
        this.fileState = new NotDealState();      
    }                                             
                                                  
    /**                                           
     * 文件状态切换为正在处理状态                              
     */                                           
    public void Dealing(){                        
                                                  
        this.fileState = new DealingState();      
    }                                             
                                                  
    /**                                           
     * 文件状态切换为已经处理状态                              
     */                                           
    public void HasDeal(){                        
                                                  
        this.fileState = new HasDealState();      
    }                                             
                                                  
    /**                                           
     * 获取当前文件的状态                                  
     */                                           
    public void getFileState(){                   
        fileState.fileState();                    
    }                                             
}                                                 

 

上下文类主要就是封装当前文件状态并且对外提供状态切换的方法

最后看下怎么使用吧： 

public class Client {                                 
                                                      
    public static void main(String[] args) {          
                                                      
        FileContext fileContext = new FileContext();  
        fileContext.getFileState();                   
        //切换为正在处理状态                                   
        fileContext.Dealing();                        
        fileContext.getFileState();                   
        //切换为已经处理状态                                   
        fileContext.HasDeal();                        
        fileContext.getFileState();                   
    }                                                 
}                                                     

 

外部使用调用相应切换状态方法就可以了，很简单，没有什么需要特别说明的。

八、状态模式与策略模式区别以及联系

策略模式与状态模式及其相似，但是二者有其内在的差别，策略模式将具体策略类暴露出去，调用者需要具体明白每个策略的不同之处以便正确使用。而状态模式状态的改变是由其内部条件来改变的，与外界无关，二者在思想上有本质区别。

好了，状态模式与策略模式讲解到此为止，二者区别联系不是几句话就能说清楚，关键是思想上的不同，具体感悟需要在实践中自己慢慢体会。

参考：Java设计模式之策略模式与状态模式