策略模式定义:
策略模式定义了算法族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化独立于使用算法的客户。
样例:
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