设计模式学习笔记(六)之策略模式(Strategy)

设计模式学习笔记(六)之策略模式(Strategy)

(一):策略模式的定义:

它定义了算法家族,分别封装起来，让他们之间可以相互替换，这个模式让算法的变化，不会影响到使用的用户。

(二):策略模式体现了两个 最基本的面向对象的原则:

• 编程中使用接口，面向接口编程.
• 封装变化

(三):策略模式的意义:

使用策略模式我们可以开发出很多可以替换的组件，这样可以软件可以具备更高的可扩展性，重用性大大提高

(四):策略模式中的各种角色:

• 抽象策略角色:策略类，通常由一个接口或者抽象类实现；
• 具体策略角色:封装了相关的算法和行为;
• 环境角色:持有一个策略类的引用，然后我们客户端可以去调用;

(五):看下策略模式的结构图:

使用策略模式，我们这对一组算法，可以去把每一个算法封装到具有共同接口的独立的类中，这样我们可以进行相互退换了。这样算法可以再不影响客户端调用的情况下去发生改变,这样可以把行为和环境进行分开来。算法的具体实现是在具体策略类中。

(六):下面我们来自己模拟实现一个策略模式(首先看下例子的结构图)

①:抽象策略角色:Strategy.java

package com.jiangqq.strategy;
//抽象策略角色:接口
//定义了所有具体的策略角色的公共算法接口
public interface Strategy {
  public int calculate(int a,int b);
}

②:具体策略角色:AddStrategy.java,ReduceStrategy.java,MultiplyStrategy.java,DivideStrategy.java

package com.jiangqq.strategy;
//具体策略类:加法策略的实现类
public class AddStrategy implements Strategy {
	@Override
	public int calculate(int a, int b) {
		return a+b;
	}
}



package com.jiangqq.strategy;
//具体策略类:减法策略的实现类
public class ReduceStrategy implements Strategy {

	@Override
	public int calculate(int a, int b) {
		// TODO Auto-generated method stub
		return a-b;
	}

}



package com.jiangqq.strategy;
//具体策略类:乘法策略的实现类
public class MultiplyStrategy implements Strategy {

	@Override
	public int calculate(int a, int b) {
		// TODO Auto-generated method stub
		return a*b;
	}

}



package com.jiangqq.strategy;
//具体策略类:除法策略的实现类
public class DivideStrategy implements Strategy {

	@Override
	public int calculate(int a, int b) {
		// TODO Auto-generated method stub
		return a/b;
	}

}

③:环境角色:Context.java

package com.jiangqq.strategy;
//环境角色,持有策略类的引用，去调用该具体策略类的算法
//给客户端去进行调用
public class Context {
	//定义策略角色的引用，通过Context的构造函数传进去
	private Strategy mStrategy;
	public Context(Strategy pStrategy) {
		this.mStrategy = pStrategy;
	}
	//具体策略角色去实现算法
	public int calculate(int a,int b)
	{
		return mStrategy.calculate(a, b);
	}
}

④:Client测试类:

package com.jiangqq.strategy;
//客户端测试实例代码
public class Client {
   public static void main(String[] args) {
	  //使用加法的策略
	   Context context=new Context(new AddStrategy());
	   System.out.println(context.calculate(1, 2));
	   //使用减法的策略
	    context=new Context(new ReduceStrategy());
	   System.out.println(context.calculate(1, 2));
	   //使用乘法的策略
	    context=new Context(new MultiplyStrategy());
	   System.out.println(context.calculate(1, 2));
	   //使用除法的策略
	    context=new Context(new DivideStrategy());
	   System.out.println(context.calculate(1, 2));
  }
}

测试结果:

(七):这样的策略模式的缺点:

我们必须要知道所有的策略类，并且要我们自己去决定要去使用哪个策略类，而且这样会存在大量的策略类

为了尽可能的消除这些缺点，我们可以使用策略模式加简单工厂模式的方法来进行实现

(点击进入:工厂模式)

这时我们需要去改变一下

①:环境角色类:Context.java

package com.jiangqq.factory;

//在进行创建ContextFactory对象的时候，传入type值进行，根据不同的值，
//工厂类会进行创建出对象的策略类
//1：加法策略类 2:减法策略类 3:乘法策略类  4:除法策略
import com.jiangqq.strategy.AddStrategy;
import com.jiangqq.strategy.DivideStrategy;
import com.jiangqq.strategy.MultiplyStrategy;
import com.jiangqq.strategy.ReduceStrategy;
import com.jiangqq.strategy.Strategy;
//这是生成不同具体策略类的工程类
public class ContextFactory {
	 Strategy mStrategy=null;
	 public ContextFactory(int type)
	 {	
		 switch (type) {
		  case 1:	
			  //1：加法策略类
			  mStrategy=new AddStrategy();
			break;
		  case 2: 
			  // 2:减法策略类
			  mStrategy=new ReduceStrategy();
			break;
		  case 3: 
			  // 3:乘法策略类  
			  mStrategy=new MultiplyStrategy();
			break;
		  case 4:
			  //4:除法策略
			  mStrategy=new DivideStrategy();
			break;
		}
	 } 
	 public int calculate(int a,int b)
	 {
		 return mStrategy.calculate(a, b);
	 }
}

②:客户端测试类：

package com.jiangqq.factory;
//在进行创建ContextFactory对象的时候，传入type值进行，根据不同的值，
//工厂类会进行创建出对象的策略类
//1：加法策略类 2:减法策略类 3:乘法策略类  4:除法策略
public class Client {
  public static void main(String[] args) {
	//进行加法的策略
	ContextFactory contextFactory=new ContextFactory(1);
	System.out.println(contextFactory.calculate(1, 2));
	//进行减法的策略
	contextFactory=new ContextFactory(2);
	System.out.println(contextFactory.calculate(1, 2));
	//进行乘法的策略
	contextFactory=new ContextFactory(3);
	System.out.println(contextFactory.calculate(1, 2));
	//进行除法的策略
	contextFactory=new ContextFactory(4);
	System.out.println(contextFactory.calculate(1, 2));
}
}

//在进行创建ContextFactory对象的时候，传入type值进行，根据不同的值，
//工厂类会进行创建出对象的策略类
//1：加法策略类 2:减法策略类 3:乘法策略类 4:除法策略，此时根据不同的策略类去调用的算法，实现不同的行为.

使用策略模式，我们简化测试，因为每个算法都是在定义具体的类中，可以进行单独的测试。策略模式是用来封装算法并且可以封装任何类型的行为，所有在使用中如果要在不同的时间要去应用不同的规则，那我们可以去使用策略模式实现.

代码下载链接地址:http://download.csdn.net/detail/jiangqq781931404/4202470