Design Pattern

Strategy Pattern:

    The Strategy Pattern defines a family of algorithms,encapsulates each one,and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

第一个设计原则

　　找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起，把会变化的部分取出并“封装”起来，好让其他部分不受影响。从而使变化引起的不经意后果变少，系统更有弹性，实现对改变关闭对扩展开放的原则。在实际的编码过程中可以随心所遇的使用多态，继承，封装三大特性。

第二个设计原则

　　针对接口编程而不是针对实现编程。

第三个设计原则

　　多用组合，少用继承。

策略模式组成：

　　—抽象策略角色： 策略类，通常由一个接口或者抽象类实现。

　　—具体策略角色：包装了相关的算法和行为，当然这些算法和行为表现为代码要求可重用，否则就没有意义(模式的局限性)。

　　—环境角色：持有一个策略类的引用，最终给客户端调用。

策略模式的应用场景：

　　1、 多个类只区别在表现行为不同，可以使用Strategy模式，在运行时动态选择具体要执行的行为。

　　2、 需要在不同情况下使用不同的策略(算法)，或者策略还可能在未来用其它方式来实现。

　　3、 对客户隐藏具体策略(算法)的实现细节，彼此完全独立。

具体应用案例

package cn.com.dp.characters;

import cn.com.dp.imp.Weapon;

public abstract class Character {
    //Character有一个weapon接口对应的行为
    private Weapon weapon;

    public Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
    
    public abstract void fight();
    public abstract String selfInfo();
}

package cn.com.dp.characters;


/**
 * 角色：郭嘉
 * 
 * @author cpt
 * 
 */
public class GuoJia extends Character {
    @Override
    public void fight() {
        System.out.print(selfInfo());
        super.getWeapon().attack();
    }

    @Override
    public String selfInfo() {
        return "呵呵，就这样吧....";
    }
}

package cn.com.dp.characters;

/**
 * 角色：贾诩
 * @author cpt
 *
 */
public class JiaXu extends Character{

    @Override
    public void fight() {
        System.out.print(selfInfo());
        getWeapon().attack();
    }

    @Override
    public String selfInfo() {
        return "我能完杀！！！";
    }
    
}

package cn.com.dp.imp;
/**
 * 所有武器攻击效果接口
 * @author cpt
 *
 */
public interface Weapon {
    void attack();
}

package cn.com.dp.impl;

import cn.com.dp.imp.Weapon;
/**
 * 诸葛连弩攻击效果，可复用替换
 * @author cpt
 *
 */
public class AK47 implements Weapon {

    @Override
    public void attack() {
        System.out.println("AK47连续攻击效果");
    }

}

package cn.com.dp.impl;

import cn.com.dp.imp.Weapon;
/**
 * 麒麟弓攻击效果,可复用替换
 * @author cpt
 *
 */
public class UnicornBow implements Weapon {

    @Override
    public void attack() {
        System.out.println("麒麟弓命中射马攻击效果");
    }

}

package cn.com.dp.context;

import cn.com.dp.characters.GuoJia;
import cn.com.dp.characters.JiaXu;
import cn.com.dp.impl.AK47;
import cn.com.dp.impl.UnicornBow;

public class StrategyTestContext {
    public static void main(String[] args) {
        AK47 ak47 = new AK47();
        UnicornBow unicornBow=new UnicornBow();
        
        GuoJia guoJia = new GuoJia();
        guoJia.setWeapon(ak47);
        guoJia.fight();
        
        JiaXu jiaXu = new JiaXu();
        jiaXu.setWeapon(unicornBow);
        jiaXu.fight();
        
        jiaXu.setWeapon(ak47);
        jiaXu.fight();
    }
}

关于策略模式能不能消除if else判断结构，个人认为策略模式是做不到。

　　http://programmers.stackexchange.com/questions/146761/design-pattern-for-handling-a-response

　　http://industriallogic.com/xp/refactoring/conditionalWithStrategy.html

个人对策略模式理解总结：

　　所有的设计模式并不是为了为了约定编程规范，而是一种总结下来针对特定需求的设计模式而绝不是编程模式，完全没有必要刻意去迁就设计模式，而且设计模式并不是什么高深的技术不过是巧妙地运用Java特性对代码进行解耦。但是了解各个模式的设计技巧核心本质对以后设计项目以及编写模块代码会有很大的帮助。策略模式巧妙的地方在于把应用中一类相似的变化的行为代码封装成可复用独立于执行环境的组件供策略环境角色随意组合调用，如果变化的行为代码不可复用那么就没有必要使用策略模式。