定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。策略模式使这些算法在客户端调用它们的时候能够互不影响地变化。（java的treeset集合中，构造方法可传入具体的比较器对象以实现不同的排序算法。就是利用的策略模式）策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中， 从而使得它们可以相互替换，使用策略模式可以把行为和环境分割开来。
环境角色：持有一个策略类的引用，最终给客户端调用的。通过环境角色指定策略。
模 拟 鸭 子 游 戏 ：simuduck。游戏中会出现各种鸭子，一边游泳戏水，一边呱
呱叫。不同的鸭子有不同的行为，所以我们可以把鸭子会不会飞，怎么飞的行为定义为抽象策略角色，鸭子叫行为也定义成一种策略，因为叫法不同。
把会变化的部分取出并封装起来，以便以后可以轻易地改动或扩充此部分，而不影响不需要变化的其他部分。
我们先抽象一个duck类，鸭子有 fly() 和 quack() ，但是会随着鸭子的不同而改变，所以我们要抽出来，将他们定义为变的部分涉及成策略，duck 类持有对应策略的引用，通过组合的方式实现。
最后我们整合鸭子的行为，分别将鸭子的飞行与嘎嘎叫的动作 "委托"（delagate）别人处理，而不是定义在duck类中。
我们用两个相似的方法performfly()和performquack()取代鸭子类中的fly()与quack()。
定义 duck 抽象类，所有的鸭子都继承。通过组合代理的模式实现飞行与嘎嘎叫的功能，持有策略类（飞行，呱呱叫）的引用。
提供set方法指定不同的策略，然后通过 performfly 与 performquack 委托对应的策略实现。
我要评论public abstract class duck {
flybehavior flybehavior;
quackbehavior quackbehavior;
public void performfly() {
flybehavior.fly();
}
public void performquack() {
quackbehavior.quack();
}
/**
* 展示鸭子
*/
public abstract void display();
public void setflybehavior(flybehavior flybehavior) {
this.flybehavior = flybehavior;
}
public void setquackbehavior(quackbehavior quackbehavior) {
this.quackbehavior = quackbehavior;
}
}
定义野鸭子：会飞，呱呱叫。
public class mallardduck extends duck {
@override
public void display() {
system.out.println("我是一只野鸭子");
}
}
定义模型鸭子：不会飞也不会叫。
public class modelduck extends duck {
@override
public void display() {
system.out.println("我是一只模型鸭子");
}
}
叫声抽象策略
public interface quackbehavior {
void quack();
}
飞行抽象策略
public interface flybehavior {
void fly();
}
实现抽象策略，规定算法逻辑。
public class flynoway implements flybehavior {
@override
public void fly() {
system.out.println("老司机带带我，我不会飞");
}
}
public class flywithwings implements flybehavior {
@override
public void fly() {
system.out.println("我会飞行，一冲云霄");
}
}
public class quack implements quackbehavior {
@override
public void quack() {
system.out.println("呱呱叫");
}
}
public class mutequack implements quackbehavior {
@override
public void quack() {
system.out.println("我不会叫");
}
}
public class mallardduck extends duck {
@override
public void display() {
system.out.println("我是一只野鸭子");
}
}
public class modelduck extends duck {
@override
public void display() {
system.out.println("我是一只模型鸭子");
}
}
public class miniducksimulator {
public static void main(string[] args) {
//定义不会叫不会飞的鸭子
flybehavior flybehavior = new flynoway();
quackbehavior quackbehavior = new mutequack();
duck modelduck = new modelduck();
//这里我们可以设置不同的行为实现类就会执行不同的策略
modelduck.setflybehavior(flybehavior);
modelduck.setquackbehavior(quackbehavior);
modelduck.display();
modelduck.performfly();
modelduck.performquack();
system.out.println("-------------------");
// 定义会叫会飞的鸭子
flybehavior flywithwings = new flywithwings();
quackbehavior quack = new quack();
duck mallardduck = new mallardduck();
mallardduck.setflybehavior(flywithwings);
mallardduck.setquackbehavior(quack);
mallardduck.display();
mallardduck.performfly();
mallardduck.performquack();
}
}
其实就是将将不同的算法抽象，通过上下文切换策略实现不同行为。我们是不是还可以使用策略模式代替很多的if else 判断执行不同的算逻辑？这里留给读者去发现使用场景。
关注公众号 javastorm 获取最新文章，不点个赞么？
如对本文有疑问， 点击进行留言回复！！
网友评论