设计模式《一》_策略模式

定义：

　　策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。封装各方法，灵活调用方法来处理所需要的业务场景。

应用场景：

　　 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。

　　 2、一个系统需要动态地在几种算法中选择一种。

　　 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

 　　这里说的算法非“冒泡”、“快速”..类的算法，是为一段解决某种业务场景的代码、操作。

常见情况：

　　多个if..else的场景、满足条件只需执行某一个方法，而多个if..else带来的难维护性，以及业务变动带来的代码修改。

 

实际例子：

　　

Operation 接口：

public interface Operation {

    public int doCompute(int num1,int num2);
}

实现类，加减法：

public class OperationSub implements Operation {
    @Override
    public int doCompute(int num1, int num2) {
        return num1 - num2;
    }
}

public class OperationAdd implements Operation {
    @Override
    public int doCompute(int num1, int num2) {
        return num1 + num2;
    }
}

计算器类：

public class Calculator {
        private Operation operation;

        private void setOperation(Operation operation){
                this.operation = operation;
        }

        private int doOperation(int num1,int num2){
                return this.operation.doCompute(num1,num2);
        }   
}

测试类：

public static void main(String[] args) {
                Calculator calculator = new Calculator();
                calculator.setOperation(new OperationAdd());
                int result = calculator.doOperation(21,4);
                System.out.println(result);
        }

 如果需要增加其它的方法，就需要新建一个类实现Operation接口，然后setOperation(new ...)。
 

优点:
　　遵循了开闭原则，扩展性良好。
缺点:
　　1.随着你的策略增加，你的类也会越来越多。
　　2.所有的策略类都要暴露出去，所以如果你在实际开发中使用了策略模式，一定要记得写好文档让你的伙伴们知道已有哪些策略。就像 Shiro 默认提供了三种验证策略，就必须在文档中写清楚，否则我们根本不知道如何使用。

---

来做一个小游戏
大概思路是不同的角色使用不同的武器打怪。
1.首先来个Role类

public abstract class Role {

    //武器
    public Weapon weapon;

    //跳跃
    public JumpAction jumpAction;

    //设置装备
    public void setWeapon(Weapon weapon){
        this.weapon = weapon;
    }

    //设置跳跃方式
    public void setJumpAction(JumpAction jumpAction){
        this.jumpAction = jumpAction;
    }

    public void useWeapon(){
        weapon.killTheMonster();
    }

    public void jump(){
        jumpAction.jump();
    }
    public abstract void appearance();

}

2.武器。手枪、AK47实现武器

public interface Weapon {
    void killTheMonster();
}

 

public class Gun implements Weapon{
    @Override
    public void killTheMonster() {
        System.out.println("拿着手枪打小怪");
    }
}

public class AK47 implements Weapon {

    @Override
    public void killTheMonster() {
        System.out.println("AK47威力大，打小怪老好使了...");
    }


}

4.跳的行为。飞起跳，二连跳。

public interface JumpAction {

    void jump();
}

public class FlyJump implements JumpAction {

    @Override
    public void jump() {
        System.out.println("飞起来跳...");
    }
}

public class ContinuousJump implements JumpAction {
    @Override
    public void jump() {
        System.out.println("可以连跳两下...");
    }
}

5.来一个机械师的角色。

public class Mechanician extends Role {

    public Mechanician(){
        //默认武器
        setWeapon(new Gun());
        //默认跳跃方式
        setJumpAction(new ContinuousJump());

    }

    @Override
    public void appearance() {
        System.out.println("穿着皮大衣的机械师...");
    }
}

6.游戏开始，测试类

public class StartGame {

    public static void main(String[] args) {
        Mechanician mechanician = new Mechanician();
        mechanician.appearance();
        mechanician.setWeapon(new AK47());
        mechanician.useWeapon();
        mechanician.jump();
    }
}

输出：

穿着皮大衣的机械师...
AK47威力大，打小怪老好使了...
可以连跳两下...

 

总结

• 面向对象，多利用组装，少用继承。
• 设计的时候面向接口设计，而不是具体的实现。
• 找出公共部分来抽象，一般是对某种行为进行抽象化。
• 以后再悟吧。