策略模式，简单工厂模式结合

概念：定义了算法家族，分别封装起来。让他们之间可以相互替换，随着算法的变换，不会影响客户端代码。

！图自己看，Context与Strategy聚合

//定义抽象策略类
public abstract class Strategy {    
     /**
      * @describe 定义抽象策略的方法,容易扩展不同策略
      * @param a
      * @param b
      * @return
      */
     public abstract int strategy(int a,int b);
};
//具体策略
public class AddStrategy extends Strategy{
     /**
      * @describe 定义抽象策略的方法,容易扩展不同策略
      * @param a
      * @param b
      * @return 定义实现加法的策略方法,定义公共的方法（返回）
      */
    public int strategy(int a, int b)
    {
        return a+b;
    }

}

public class SubStrategy {

      //定义减法的策略方法
    public int strategy(int a, int b)
    {
        return a-b;
    }


}

public class MultiplyStrategy {
    //定义乘法的策略方法
    public int strategy(int a,int b)
    {
        return a*b;
    }
}

public class DivStrategy {
    //定义除法的策略方法，这里为了简单就不考虑除数为零的情况了
    public int strategy(int a,int b)
    {
        return a/b;
    }
}

/**
 * 
 * @author Administrator
 * @descripe 策略引用类，目的是将客户端与策略类分离
 */
public class Context {

     //持有抽象策略角色的引用，用于客户端调用
    private Strategy strategy;
    //获得策略类
    public Strategy getStrategy() {
        return strategy;
    }
    //设置所需策略
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;

    }
    //根据设置的策略类返回对应的结果
    public int getResult(int a,int b)
    {
        return strategy.strategy(a, b);
    }

}

简单工厂与策略模式结合

目的：工厂类与策略类的引用类结合，减少代码的耦合度，只需知道Factory,Context俩类即可。将工厂类解放出来！

//工厂类
public class Factory {

     public Strategy createStrategy(String str)
        {
            if("AddStrategy".equalsIgnoreCase(str))
            {
                return new AddStrategy();
            }
            else
                if("SubStrategy".equalsIgnoreCase(str))
                {
                    return new SubStrategy();
                }
                else
                    if("DivStrategy".equalsIgnoreCase(str))
                    {
                        return new DivStrategy();
                    }
                    else
                        if("MultiplyStrategy".equalsIgnoreCase(str))
                        {
                            return new MultiplyStrategy();
                        }
                        else
                            return null;
        }

}

/**
 * 客户端
 * @author 
 *    Client
 */
public class Client {
    public static void main(String[] args) {

        Context context = new Context();
        int result;
        Strategy strategy;
        Factory fac = new Factory();
        strategy = fac.createStrategy("AddStrategy");
        context.setStrategy(strategy);
            result = context.getResult(9, 3);
        System.out.println(result);
    }
}