设计模式（二）学习----策略模式

•  策略设计模式：定义一组算法，将每个算法都分装起来，并使他们之间可以互换。 策略模式就是使用的面向对象思想中的继承和多态的机制
  
  

策略模式的通用类图：

1. Context类：Strategy类，并且和Strategy类是整体和个体的关系，即聚合关系。对策略角色个体进行封装。
2. Strategy接口：定义这个策略或算法必须有的方法和属性。
3. ConcreteStrategy1，ConcreteStrategy2具体策略角色实现类。实现抽象策略中的方法，该类中含有具体的算法。

上图变成Java代码：

抽象的策略角色：

package com.lp.ecjtu.strategy1;

public interface Strategy {
    /**
     * 策略模式的运算法则,抽象的策略角色
     */
    public void doSomething();
}

具体的策略角色：

package com.lp.ecjtu.strategy1;

public class ConcreteStrategy1 implements Strategy {

    @Override
    public void doSomething() {
        System.out.println("具体策略1的运算法则");
    }
}


package com.lp.ecjtu.strategy1;

public class ConcreteStrategy2 implements Strategy {

    @Override
    public void doSomething() {
        System.out.println("具体策略2的运算法则");
    }

}

封装角色：

 

package com.lp.ecjtu.strategy1;

public class Context {
    //抽象策略，与Strategy接口是聚合关系
    private Strategy strategy;
    //构造函数设置具体策略
    public Context(Strategy conStrategy){
        this.strategy = conStrategy;
    }
    //封装后的策略方法
    public void doAnyThing(){
        this.strategy.doSomething();
    }
}

高层模块：

package com.lp.ecjtu.strategy1;

public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //声明一个具体的策略，父类的引用指向子类，使用多态
        Strategy strategy = new ConcreteStrategy1();
        Context  context = new Context(strategy);
        context.doAnyThing();
        
        Strategy strategy2 = new ConcreteStrategy2();
        Context  context2 = new Context(strategy2);
        context2.doAnyThing();
    }

}

策略模式的优点：

1. 算法可以自由切换：通过Context类对策略成员进行封装，保证对外提供"可自由切换”的策略。
2. 避免使用多重条件判断，
3. 扩展性良好

策略模式的缺点:

1. 策略类数量太多:每一个策略都是一个类，复用性很小，类数量增多。
2. 所有策略类都需要向外暴露：客户端必须知道有哪些策略才能决定使用哪一个策略。导致封装类没有意义，可以使用工厂模式解决。

应用：

我们假设有如下场景：

      我们使用聊天工具聊天时，可以发送点对点消息（私聊）和点对多消息（群聊），而发送不同的消息执行的操作是不一样的，也就是说我们在不同的场景下（私聊或者 群聊）发送消息时会调用不同的发送方法，但是我们只有一个消息发送器（可以理解为发送消息时的发送按钮），我们希望可以通过这消息发送器发送任何类型的消 息。

java代码：

  

package com.lp.ecjtu.strategy;

public interface IMessage {
    /**
     * ClassName:IMessage 
     * Function: 这是一个消息的接口，所有的消息都要实现这个接口. 
     * Reason:   TODO ADD REASON. 
     * Date:     2014-8-12 上午11:33
     * @author   lipeng 
     * @version 
     * @since    JDK 1.6 
     * @see 
     */
    public void send();
}

package com.lp.ecjtu.strategy;

public class P2MMsg implements IMessage {

    @Override
    public void send() {
        // TODO Auto-generated method stub
        System.out.println("这是点对多的消息，将发送给多个人");
    }
  
}


package com.lp.ecjtu.strategy;

public class P2PMessage implements IMessage {

    @Override
    public void send() {
        // TODO Auto-generated method stub
        System.out.println("这是点对多的消息，将发送给一个人");
    }

}

package com.lp.ecjtu.strategy;

/**
 * 封装角色
 * @author Administrator
 *
 */
public class MessageSender {
    //抽象策略，要使用的消息
    private IMessage message;//与IMessage是聚合关系
    //构造函数设置具体策略，你要使用哪种消息
    public MessageSender(IMessage message){
        this.message = message;
    }
    
    public void send(){
        this.message.send();
    }
}

package com.lp.ecjtu.strategy;
/**
 * 策略设计模式：定义一组算法，将每个算法都分装起来，并使他们之间可以互换。
 * 策略模式就是使用的面向对象思想中的继承和多态的机制。
 * 
 * 
 * @author Administrator
 *
 */
public class UserClient {

    /**
     * 依次发送一条点对点的消息，和点对多的消息。
     */
    public static void main(String[] args) {
        //建立发送器
        MessageSender msgSender;
        System.out.println("发送一条点对点的消息：");
        msgSender = new MessageSender(new P2PMessage());
        msgSender.send();
        System.out.println("发送一条点对多的消息：");
        msgSender  = new MessageSender(new P2MMsg());
        msgSender.send();
    }

}

 

 

 

策略模式spring结合： https://www.cnblogs.com/CodeBear/p/13213347.html