Java设计模式--策略模式

1、什么是策略模式？

策略模式，又叫算法簇模式，就是定义了不同的算法，并且之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

2、策略模式有什么好处？

策略模式的好处是让你可以动态地改变对象的行为。

3、设计原则

找出应用中相同之处，且不容易发生变化的东西，把它们抽象到抽象类中，让子类去继承它们；

找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

4、策略模式的三个对象

（1）  环境对象：该类中实现了对抽象策略中定义的接口或者抽象类的引用。

（2）  抽象策略对象：它可由接口或抽象类来实现。

（3）  具体策略对象：它封装了实现不同功能的不同算法。

5、应用场景举例

（1）  应用场景1

故事：锦囊妙计+赔了夫人又折兵

 

package com.lt.strategy;
/**
 * 首先定义一个策略接口，这是诸葛亮给赵云的三个锦囊妙计的接口(抽象策略)
 * @author LiuTao
 *
 */
public interface IStrategy {
	//每个锦囊妙计都有一个可执行的算法
	public void operate();
}

package com.lt.strategy;
/**
 * 首先定义一个策略接口，这是诸葛亮给赵云的三个锦囊妙计的接口(抽象策略)
 * @author LiuTao
 *
 */
public class BackDoor implements IStrategy {


<span style="white-space:pre">	</span>@Override
<span style="white-space:pre">	</span>public void operate() {  
        System.out.println("找乔国老帮忙，让吴国太给孙权施加压力，使孙权不能杀刘备...");  
    }
}

package com.lt.strategy;
/**
 * 求吴国太开个绿灯(具体策略2)
 * @author LiuTao
 *
 */
public class GivenGreenLight implements IStrategy {

	@Override
	public void operate() {
		System.out.println("求吴国太开个绿灯。");
	}

}

package com.lt.strategy;
/**
 * 孙夫人断后，挡住追兵(具体策略3)
 * @author LiuTao
 *
 */
public class BlackEnemy implements IStrategy {

	@Override
	public void operate() {
		System.out.println("孙夫人断后，挡住追兵。");
	}

}

package com.lt.strategy;
/**
 * 存放锦囊的地方
 * @author LiuTao
 *
 */
public class Context {
	private IStrategy strategy;
	//构造函数，要你使用哪个妙计
	public Context(IStrategy strategy){
		this.strategy = strategy;
	}
	
	public void operate(){
		this.strategy.operate();
	}
}

package com.lt.strategy;

public class ZhaoYun {
	/**
	 * 赵云出场了，他根据诸葛亮给他的交代，一次拆开妙计
	 * @param args
	 */
	public static void main(String[] args) {
		Context context;
		//刚到吴国的时候拆开第一个
		System.out.println("刚刚到吴国的时候拆开第一个");
		context=new Context(new BackDoor());
		context.operate();//拆开执行
		System.out.println("\n\n\n");
		
		//当刘备乐不思蜀时，拆开第二个
		System.out.println("刘备乐不思蜀，拆开第二个");
		context=new Context(new GivenGreenLight());
		context.operate();//拆开第二个
		System.out.println("\n\n\n");
		
		//孙权的追兵？拆开第三个
		System.out.println("孙权的追兵，拆开第三个");
		context=new Context(new BlackEnemy());
		context.operate();
		System.out.println("\n\n\n");
	}

}

 

 

 

（2）  应用场景2

为了要分开“变化和不变化的部分”，我们准备建立两组类（完全远离Duck类），一个是“fly”相关的类，另一个是“quark”相关的类。没一组类实现各自的动作。比如说我们有一个类可以实现“呱呱叫”，另一个类可以实现“叽叽叫”，首先写两个接口。FlyBehavior(飞行行为)和QuackBehavior(叫的行为)。

 

package com.lt.strategy2;

public interface FlyBehavior {
	public void fly();
}

package com.lt.strategy2;

public interface QuackBehavior {
	public void quack();
}

具体实现类：

 

 

package com.lt.strategy2;

public class FlyWithWings implements FlyBehavior {

	@Override
	public void fly() {
		System.out.println("拥有翅膀的鸭子，可以飞行");
	}

}

package com.lt.strategy2;

public class FlyNoWay implements FlyBehavior {
	@Override
	public void fly() {
		System.out.println("没有翅膀的鸭子，不会飞行。");
	}
}

 

 

package com.lt.strategy2;

public class Quack implements QuackBehavior {

	@Override
	public void quack() {
		System.out.println("呱呱叫");
	}

}

package com.lt.strategy2;

public class Squeak implements QuackBehavior {

	@Override
	public void quack() {
		System.out.println("叽叽叫");
	}

}

package com.lt.strategy2;

public class MuteQuack implements QuackBehavior {

	@Override
	public void quack() {
		System.out.println("不会叫");
	}

}

Duck的设计

 

package com.lt.strategy2;

public abstract class Duck {
	FlyBehavior flyBehavior;
	QuackBehavior quackBehavior;
	public Duck(){};
	public abstract void display();
	public void swim(){
		System.out.println("游泳");
	}
	public void performFly(){
		flyBehavior.fly();
	}
	public void performQuack(){
		quackBehavior.quack();
	}
}

package com.lt.strategy2;

public class MallardDuck extends Duck {
	public MallardDuck() {
		flyBehavior=new FlyWithWings();
		quackBehavior=new Quack();
	}

	@Override
	public void display() {
		System.out.println("蓝色");
	}
}