设计模式：策略模式（Strategy Pattern）

策略模式定义：

策略模式定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

样例：

UML类图

Java代码实现：

Duck.java

/**
 * 鸭子超类
 * @author LiuJing
 *
 */
public abstract class Duck {

  FlyBehavior flyBehavior;
  QuackBehavior quackBehavior;
  
  public abstract void display();
  
  public void performFly(){
    flyBehavior.fly();
  }
  
  public void performQuack() {
    quackBehavior.quack();
  }
  
  public void swim(){
    System.out.println("All ducks float, even decoys!");
  }
  
  
  // 新加入2个设定行为的方法
  public void setFlyBehavior(FlyBehavior fb){
    flyBehavior = fb;
  }
  public void setQuackBehavior(QuackBehavior qb){
    quackBehavior = qb;
  }
}

FlyBehavior.java

/**
 * 飞的行为 接口类
 * @author LiuJing
 *
 */
public interface FlyBehavior {
  public void fly();
}

FlyWithWings.java

/**
 * 用翅膀飞的类
 * @author LiuJing
 *
 */
public class FlyWithWings implements FlyBehavior{
  public void fly(){
    System.out.println("I'm flying!!!");
  }
}

FlyNoWay.java

/**
 * 不能飞的类
 * @author LiuJing
 *
 */
public class FlyNoWay implements FlyBehavior{
  public void fly() {
    // TODO Auto-generated method stub
    System.out.println("I can't fly");
  }
}

FlyRocketPowered.java

/**
 * 用火箭飞的类
 * @author LiuJing
 *
 */
public class FlyRocketPowered implements FlyBehavior {

  public void fly() {
    // TODO Auto-generated method stub
    System.out.println("I'm flying with a rocket");
  }
}

QuackBehavoir.java

/**
 * 叫的行为 接口
 * @author LiuJing
 *
 */
public interface QuackBehavior {
  public void quack();
}

Quack.java

/**
 * 嘎嘎叫的类
 * @author LiuJing
 *
 */
public class Quack implements QuackBehavior{
  public void quack() {
    // TODO Auto-generated method stub
    System.out.println("Quack");
  }
}

Squeak.java

/**
 * 吱吱叫的类
 * @author LiuJing
 *
 */
public class Squeak implements QuackBehavior{
  public void quack() {
    // TODO Auto-generated method stub
    System.out.println("Squeak");
  }
}

MuteQuack.java

/**
 * 沉默不叫的类
 * @author LiuJing
 *
 */
public class MuteQuack implements QuackBehavior{
  public void quack() {
    // TODO Auto-generated method stub
    System.out.println("Silence");
  }
}

MallardDuck.java

/**
 * 绿头鸭
 * @author LiuJing
 *
 */
public class MallardDuck extends Duck {

  public MallardDuck(){
    quackBehavior = new Quack();
    flyBehavior = new FlyWithWings();
  }
  
  @Override
  public void display() {
    // TODO Auto-generated method stub
    System.out.println("I'm a real Mallard duck");
  }

}

ModelDuck.java

/**
 * 模型鸭
 * @author LiuJing
 *
 */
public class ModelDuck extends Duck {
  
  public ModelDuck(){
    flyBehavior = new FlyNoWay();
    quackBehavior = new Quack();
  }
  
  @Override
  public void display() {
    // TODO Auto-generated method stub
    System.out.println("I'm a model duck");
  }
}

现在写一个测试类，用以测试：

Test.java

/**
 * 测试类
 * @author LiuJing
 *
 */

public class Test {

  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    
    // 测试绿头鸭
    System.out.println("--------测试绿头鸭--------");
    Duck mallard = new MallardDuck();
    mallard.performQuack();
    mallard.performFly();
    
    // 测试模型鸭
    System.out.println("--------测试模型鸭---------");
    Duck model = new ModelDuck();
    model.performQuack();
    model.performFly();
    // 改变其飞行行为
    model.setFlyBehavior(new FlyRocketPowered());
    model.performFly();
  }
}

输出：

--------测试绿头鸭--------
Quack
I'm flying!!!
--------测试模型鸭---------
Quack
I can't fly
I'm flying with a rocket

策略模式C＃实现样例：

UML类图：

C#实现代码：

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PatternTest
{
    // 策略抽象类
    abstract class Strategy
    {
        public abstract void AlgorithmInterface();
    }

    // 算法A
    class ConcreteStrategyA : Strategy
    {
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法A实现");
        }
    }

    // 算法B
    class ConcreteStrategyB : Strategy
    {
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法B实现");
        }
    }

    // 算法C
    class ConcreteStrategyC : Strategy
    {
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法C实现");
        }
    }

    // 具体使用算法的类
    class Context
    {
        Strategy strategy;
        public Context(Strategy strategy)
        {
            this.strategy = strategy;
        }

        public void ContextInterface()
        {
            strategy.AlgorithmInterface();
        }
    }

    // 测试代码
    class Program
    {
        static void Main(string[] args)
        {
            Context context;
            context = new Context(new ConcreteStrategyA());
            context.ContextInterface();

            context = new Context(new ConcreteStrategyB());
            context.ContextInterface();

            context = new Context(new ConcreteStrategyC());
            context.ContextInterface();

            Console.Read();
        }
    }
}

输出：

算法A实现
算法B实现
算法C实现

C#具体实例：

代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PatternTest
{
    // 现金收费抽象类
    abstract class CashSuper
    {
        public abstract double acceptCash(double money);
    }

    // 正常收费子类
    class CashNormal : CashSuper
    {
        public override double acceptCash(double money)
        {
            return money;
        }
    }

    // 打折收费子类
    class CashRebate : CashSuper
    {
        private double moneyRebate = 1d;

        public CashRebate(double moneyRebate)
        {
            this.moneyRebate = moneyRebate;
        }
        public override double acceptCash(double money)
        {
            return money * moneyRebate;
        }
    }

    // 返利收费子类
    class CashReturn : CashSuper
    {
        private double moneyCondition = 0.0d;
        private double moneyReturn = 0.0d;
        public CashReturn(double moneyCondition, double moneyReturn)
        {
            this.moneyCondition = moneyCondition;
            this.moneyReturn = moneyReturn;
        }
        public override double acceptCash(double money)
        {
            double result = money;
            if (money >= moneyCondition)
            {
                result = money - Math.Floor(money / moneyCondition) * moneyReturn;
            }

            return result;
        }
    }

    //class CashFactory
    //{
    //    public static CashSuper createCashAccept(int type)
    //    {
    //        CashSuper cs = null;
    //        switch (type)
    //        {
    //            case 1: // "正常收费"
    //                cs = new CashNormal();
    //                break;
    //            case 2: // "满300返100"
    //                cs = new CashReturn(300, 100);
    //                break;
    //            case 3: // "打8折"
    //                cs = new CashRebate(0.8);
    //                break;
    //        }

    //        return cs;
    //    }
    //}

    // 改进CashFactory,请仔细对比上一个注释的类，这么做有什么好处？
    // 好处：
    // 隐藏了 CashSuper 对象及其方法 acceptCash
    class CashContext
    {
        private CashSuper cs;
        public CashContext(int type)
        {
            switch (type)
            {
                case 1: // "正常收费"
                    cs = new CashNormal();
                    break;
                case 2: // "满300返100"
                    cs = new CashReturn(300, 100);
                    break;
                case 3: // "打8折"
                    cs = new CashRebate(0.8);
                    break;
            }
        }

        public double getResult(double money)
        {
            return cs.acceptCash(money);
        }
    }


    // 测试代码
    class Program
    {
        static void Main(string[] args)
        {
            //选择一种折扣类型
            // 1,正常收费 2,满300返100 3,打8折
            double total = 0.0d;
            double totalPrices = 0d;
            
            
            //CashSuper csuper = null;

            //Console.WriteLine("----------测试正常收费-----------");
            //csuper = CashFactory.createCashAccept(1);
            //totalPrices = csuper.acceptCash(500);//金额为客人在店里消费的随机数额 单价*数额 多种
            //Console.WriteLine("消费总额为："+ totalPrices);
            //total += totalPrices;

            //Console.WriteLine("----------测试满300减100-----------");
            //csuper = CashFactory.createCashAccept(2);
            //totalPrices = csuper.acceptCash(1400);//金额为客人在店里消费的随机数额 单价*数额 多种
            //Console.WriteLine("消费总额为：" + totalPrices);
            //total += totalPrices;

            //Console.WriteLine("----------测试8折-----------");
            //csuper = CashFactory.createCashAccept(3);
            //totalPrices = csuper.acceptCash(1000);//金额为客人在店里消费的随机数额 单价*数额 多种
            //Console.WriteLine("消费总额为：" + totalPrices);
            //total += totalPrices;


            // 改进代码后的再测试
            CashContext cc = null;

            Console.WriteLine("----------测试正常收费-----------");
            cc = new CashContext(1);
            totalPrices = cc.getResult(500);//金额为客人在店里消费的随机数额 单价*数额 多种
            Console.WriteLine("消费总额为：" + totalPrices);
            total += totalPrices;

            Console.WriteLine("----------测试满300减100-----------");
            cc = new CashContext(2);
            totalPrices = cc.getResult(1400);//金额为客人在店里消费的随机数额 单价*数额 多种
            Console.WriteLine("消费总额为：" + totalPrices);
            total += totalPrices;

            Console.WriteLine("----------测试8折-----------");
            cc = new CashContext(3);
            totalPrices = cc.getResult(1000);//金额为客人在店里消费的随机数额 单价*数额 多种
            Console.WriteLine("消费总额为：" + totalPrices);
            total += totalPrices;

            Console.WriteLine("总消费：" + total);

            Console.Read();
        }
    }
}

输出：

----------测试正常收费-----------
消费总额为：500
----------测试满300减100-----------
消费总额为：1000
----------测试8折-----------
消费总额为：800
总消费：2300