java设计模式（十二）：策略模式

目录

 

一：策略模式

1.引出问题

2.引出概念

二：代码

1.先上结构图

2.策略抽象

3.抽象的几个实现

3.抽象实现的调用

4.测试

三：说明

1.缺点以及解决方案

---

一：策略模式

1.引出问题

  在谈策略模式，我们先来聊聊之前讲过的一个模式：抽象工厂模式。抽象工厂模式基于工厂抽象类，有多个同参数但是实现方式不同的实现类，然后根据环境不同引用不同的字类实现。如下图：

其中存储的抽象，他的实现方法保持了一致，即参数接口方法完全一致。

  然后，我们来说说策略模式的概念：定义了不同的算法族，并且之间可以互相替换，此模式让算法的变化独立于使用算法的客户。看不懂？简而言之，如果不同了算法实现，在不同的场景有不同的实现。有人用这样来举例说明，比如有个税，中国有中国的个税方式，美国由美国的。。。

 是不是和抽象工厂有些类似？其实，我认为策略模式是抽离出多个抽象工厂，并且整合起来的。

 

2.引出概念

策略抽象类：提取出多个运算的抽象类。

策略实现类：策略抽象类的实现。

环境对象：对于不同实现类的调用。

 

二：代码

1.先上结构图

 

2.策略抽象

package test;

/*
 * 算法抽象
 */
public interface Strategy {
	
	/*
	 * 2个数进行运算
	 */
	public int calculate(int a,int b);
}

3.抽象的几个实现

package test;

/*
 * 加法运算
 */
public class AddStrategy implements Strategy{

	@Override
	public int calculate(int a, int b) {
		
		
		return a+b;
	}

}

package test;

/*
 * 减法运算
 */
public class DelStrategy implements Strategy{

	@Override
	public int calculate(int a, int b) {
		
		
		return a-b;
	}

}

package test;


/*
 * 乘法运算
 */
public class Cfystrategy implements Strategy{

	@Override
	public int calculate(int a, int b) {
		
		
		return a*b;
	}

}

package test;

/*
 * 除法运算
 */
public class MulStrategy implements Strategy{

	@Override
	public int calculate(int a, int b) {
		
		
		return a/b;
	}

}

3.抽象实现的调用

package test;

/*
 * 运算存储运算的嗲用环境
 */
public class Context {
  private Strategy strategy;

public Strategy getStrategy() {
	return strategy;
}

public void setStrategy(Strategy strategy) {
	this.strategy = strategy;
}

public Context(Strategy strategy) {
	super();
	this.strategy = strategy;
}
  
public int cacle(int a,int b){
	return strategy.calculate(a, b);
}  
	
}

4.测试

package test;

public class test {
	public static void main(String[] args) {
		Context  ct=new Context(new AddStrategy());
		System.out.println(ct.cacle(1, 2)	);
		
		
		Context  ct1=new Context(new DelStrategy());
		System.out.println(ct1.cacle(1, 2)	);
		
		
		Context  ct2=new Context(new MulStrategy());
		System.out.println(ct2.cacle(1, 2)	);
		
		Context  ct3=new Context(new Cfystrategy());
		System.out.println(ct3.cacle(1, 2)	);
	}
  
}

三：说明

1.缺点以及解决方案

  （1）扩展性比不上抽象工厂，其有一个实现类，就得去环境对象中去实现一个字类（其实完全可以用动态代理，不必去改动环境对象）

 （2）资源占用率高：每一个字类嗲用一次就会产生一个新的子类对象（可以使用享元模式来管理）