设计模式_策略模式_Strategy
案例引入
- 有各种鸭子，比如野鸭、北京鸭、水鸭等。 鸭子有各种行为，比如走路、叫、飞行等。不同鸭子的行为可能略有不同。要求显示鸭子的信息
传统方案实现
不同的鸭子继承一个父类Duck，如果是相同的行为就继承，不同行为就重写方法
实现
【鸭子抽象类】
package com.test.strategy;
public abstract class Duck {
public Duck() {
}
/**
* 显示鸭子信息
*/
public abstract void display();
/**
* 叫法
*/
public void quack() {
System.out.println("鸭子嘎嘎叫~~");
}
/**
* 游泳方法
*/
public void swim() {
System.out.println("鸭子会游泳~~");
}
/**
* 飞翔方法
*/
public void fly() {
System.out.println("鸭子会飞翔~~~");
}
}
【野鸭】
package com.test.strategy;
public class WildDuck extends Duck {
@Override
public void display() {
System.out.println(" 这是野鸭 ");
}
}
【北京鸭】
package com.test.strategy;
public class PekingDuck extends Duck {
@Override
public void display() {
System.out.println("~~北京鸭~~~");
}
/**
* 因为北京鸭不能飞翔，因此需要重写fly
*/
@Override
public void fly() {
System.out.println("北京鸭不能飞翔");
}
}
【玩具鸭】
package com.test.strategy;
public class ToyDuck extends Duck {
@Override
public void display() {
System.out.println("玩具鸭");
}
//-------需要重写父类的所有方法---------
public void quack() {
System.out.println("玩具鸭不能叫~~");
}
public void swim() {
System.out.println("玩具鸭不会游泳~~");
}
public void fly() {
System.out.println("玩具鸭不会飞翔~~~");
}
}
分析
- 缺点：因为继承了Duck，所有鸭子都有了会飞的方法，虽然可以通过覆盖fly方法来解决，但是，如果子类很多方法都不需要呢，如果每个都要去覆盖一下就很麻烦了
- 改进：使用策略模式
介绍
基本介绍
- 策略模式中，定义算法族，分别封装到不同的类中，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。使用策略模式可以整体地替换算法的实现部分，让我们可以轻松地以不同的算法去解决同一个问题
- 该模式体现了几个设计原则：把变化的代码从不变的代码中分离出来；针对接口编程而不是具体类(定义了策略接口)；多用组合/聚合，少用继承(客户通过组合方式使用策略)
登场角色
Context聚合了策略接口，后面需要使用到哪个具体策略的方法，就传入该具体策略的实例作为参数即可
Strategy(策略)：Strategy角色负责定义实现策略所必需的接口(API)ConcreteStrategy(具体的策略)：ConcreteStrategy角色负责实现Strategy角色的接口(API)，即负责实现具体的策略(战略、方向、方法和算法)Context(上下文)：负责使用Strategy角色。Context角色保存了ConcreteStrategy角色的实例，并使用ConcreteStrategy角色（即调用Strategy角色的接口）去实现需求
案例实现
案例一
类图
实现
【飞翔策略 FlyBehavior】
package com.test.strategy.improve;
public interface FlyBehavior {
/**
* 让子类具体实现
*/
void fly();
}
【叫策略 QuackBehavior】
package com.test.strategy.improve;
public interface QuackBehavior {
void quack();
}
【飞翔技术高超：GoodFlyBehavior】
package com.test.strategy.improve;
public class GoodFlyBehavior implements FlyBehavior {
@Override
public void fly() {
System.out.println(" 飞翔技术高超 ~~~");
}
}
【飞翔技术一般：BadFlyBehavior 】
package com.test.strategy.improve;
public class BadFlyBehavior implements FlyBehavior {
@Override
public void fly() {
System.out.println(" 飞翔技术一般 ");
}
}
【不会飞翔】
package com.test.strategy.improve;
public class NoFlyBehavior implements FlyBehavior{
@Override
public void fly() {
System.out.println(" 不会飞翔 ");
}
}
【鸭子抽象类】
package com.test.strategy.improve;
public abstract class Duck {
/**
* 策略接口 飞翔
*/
FlyBehavior flyBehavior;
/**
* 策略接口 叫
*/
QuackBehavior quackBehavior;
public Duck() {
}
/**
* 显示鸭子信息
*/
public abstract void display();
public void quack() {
System.out.println("鸭子嘎嘎叫~~");
}
public void swim() {
System.out.println("鸭子会游泳~~");
}
public void fly() {
//改进
if(flyBehavior != null) {
flyBehavior.fly();
}
}
public void setFlyBehavior(FlyBehavior flyBehavior) {
this.flyBehavior = flyBehavior;
}
public void setQuackBehavior(QuackBehavior quackBehavior) {
this.quackBehavior = quackBehavior;
}
}
【野鸭】
package com.test.strategy.improve;
public class WildDuck extends Duck {
/**
* 构造器，传入FlyBehavor 的对象
*/
public WildDuck() {
// 野鸭飞翔技术较强
flyBehavior = new GoodFlyBehavior();
}
@Override
public void display() {
System.out.println(" 这是野鸭 ");
}
}
【北京鸭】
package com.test.strategy.improve;
public class PekingDuck extends Duck {
/**
* 假如北京鸭可以飞翔，但是飞翔技术一般
*/
public PekingDuck() {
flyBehavior = new BadFlyBehavior();
}
@Override
public void display() {
System.out.println("~~北京鸭~~~");
}
}
【玩具鸭】
package com.test.strategy.improve;
public class ToyDuck extends Duck {
public ToyDuck() {
// 玩具鸭不会飞翔
flyBehavior = new NoFlyBehavior();
}
@Override
public void display() {
System.out.println("玩具鸭");
}
/**
* 需要重写父类的所有方法
*/
public void quack() {
System.out.println("玩具鸭不能叫~~");
}
public void swim() {
System.out.println("玩具鸭不会游泳~~");
}
}
【主类】
package com.test.strategy.improve;
public class Client {
public static void main(String[] args) {
WildDuck wildDuck = new WildDuck();
wildDuck.fly();
ToyDuck toyDuck = new ToyDuck();
toyDuck.fly();
PekingDuck pekingDuck = new PekingDuck();
pekingDuck.fly();
//可以动态改变某个对象的行为, 将北京鸭改成不能飞
pekingDuck.setFlyBehavior(new NoFlyBehavior());
System.out.println("北京鸭的实际飞翔能力");
pekingDuck.fly();
}
}
【输出】
飞翔技术高超 ~~~
不会飞翔
飞翔技术一般
北京鸭的实际飞翔能力
不会飞翔
Process finished with exit code 0
尖叫策略和飞翔策略的实现方式一样，这里就不再实现了
案例二
类图
实现
【手势类：并不是策略模式的角色】
package com.test.strategy.Sample;
/**
* 手势
*/
public class Hand {
/**
* 表示石头的值
*/
public static final int HANDVALUE_GUU = 0;
/**
* 表示剪刀的值
*/
public static final int HANDVALUE_CHO = 1;
/**
* 表示布的值
*/
public static final int HANDVALUE_PAA = 2;
/**
* 表示猜拳中3种手势的实例
*/
public static final Hand[] hand = {
new Hand(HANDVALUE_GUU),
new Hand(HANDVALUE_CHO),
new Hand(HANDVALUE_PAA),
};
/**
* 表示猜拳中手势所对应的字符串
*/
private static final String[] name = {
"石头", "剪刀", "布",
};
/**
* 表示猜拳中出的手势的值
*/
private int handvalue;
private Hand(int handvalue) {
this.handvalue = handvalue;
}
/**
* 根据手势的值获取其对应的实例，这是一种单例模式，每种手势只有一个实例
*
* @param handvalue
* @return
*/
public static Hand getHand(int handvalue) {
return hand[handvalue];
}
/**
* 如果this胜了h则返回true
*
* @param h
* @return
*/
public boolean isStrongerThan(Hand h) {
return fight(h) == 1;
}
/**
* 如果this输给了h则返回true
*
* @param h
* @return
*/
public boolean isWeakerThan(Hand h) {
return fight(h) == -1;
}
/**
* 计分：平0, 胜1, 负-1
*
* @param h
* @return
*/
private int fight(Hand h) {
if (this == h) {
return 0;
} else if ((this.handvalue + 1) % 3 == h.handvalue) {
// 当(this.handvalue + 1) % 3 == h.handvalue时，可能得手势组合如下
// this是石头，h是剪刀
// this是剪刀，h是布
// this是布，h是石头
return 1;
} else {
return -1;
}
}
/**
* 转换为手势值所对应的字符串
*
* @return
*/
public String toString() {
return name[handvalue];
}
}
【策略接口】
package com.test.strategy.Sample;
public interface Strategy {
/**
* 获取下一局要出的手势
* @return
*/
public abstract Hand nextHand();
/**
* 学习上一局的手势是否获胜了，获胜就传进来true，否则返回false
* @param win
*/
public abstract void study(boolean win);
}
【具体策略一】
package com.test.strategy.Sample;
import java.util.Random;
/**
* 该策略是：如果上一局赢了，这局的手势就和上一局的相同；如果上一局输了，就随机出
*/
public class WinningStrategy implements Strategy {
private Random random;
/**
* 保存上一局是赢还是输了
*/
private boolean won = false;
/**
* 保存上一局出的手势
*/
private Hand prevHand;
public WinningStrategy(int seed) {
random = new Random(seed);
}
public Hand nextHand() {
if (!won) {
prevHand = Hand.getHand(random.nextInt(3));
}
return prevHand;
}
public void study(boolean win) {
won = win;
}
}
【具体策略二】
package com.test.strategy.Sample;
import java.util.Random;
public class ProbStrategy implements Strategy {
private Random random;
private int prevHandValue = 0;
private int currentHandValue = 0;
/**
* 过去的胜率：history[上一局出的手势][这一局所出的手势]
* 假设上一局出的手势是石头：
* history[0][0]：两局分别出了石头、石头的获胜次数
* history[0][1]：两局分别出了石头、剪刀的获胜次数
* history[0][2]：两局分别出了石头、布的获胜次数
* 若history[0][0]=3；history[0][1]=5；history[0][2]=7
* 下一把出什么？使用轮盘赌的方式，出石头的概率是3/15；出剪刀的概率是5/15；出布的概率是7/15
*/
private int[][] history = {
{ 1, 1, 1, },
{ 1, 1, 1, },
{ 1, 1, 1, },
};
public ProbStrategy(int seed) {
random = new Random(seed);
}
/**
* 学习历史胜率，根据轮盘赌的方式来出下一个手势
* @return
*/
public Hand nextHand() {
int bet = random.nextInt(getSum(currentHandValue));
int handvalue = 0;
if (bet < history[currentHandValue][0]) {
handvalue = 0;
} else if (bet < history[currentHandValue][0] + history[currentHandValue][1]) {
handvalue = 1;
} else {
handvalue = 2;
}
prevHandValue = currentHandValue;
currentHandValue = handvalue;
return Hand.getHand(handvalue);
}
/**
* 获取第一把出hv，第二把出1、2、3的总次数
* @param hv
* @return
*/
private int getSum(int hv) {
int sum = 0;
for (int i = 0; i < 3; i++) {
sum += history[hv][i];
}
return sum;
}
/**
* 学习经验，更新 history 表格
* @param win
*/
public void study(boolean win) {
if (win) {
history[prevHandValue][currentHandValue]++;
} else {
history[prevHandValue][(currentHandValue + 1) % 3]++;
history[prevHandValue][(currentHandValue + 2) % 3]++;
}
}
}
【游戏选手类】
package com.test.strategy.Sample;
/**
* 玩猜拳游戏的选手类
*/
public class Player {
private String name;
/**
* 记录选手要选用的策略
*/
private Strategy strategy;
/**
* 赢的局数
*/
private int wincount;
/**
* 输的局数
*/
private int losecount;
/**
* 总局数
*/
private int gamecount;
/**
* 传入选手的姓名和策略
*
* @param name
* @param strategy
*/
public Player(String name, Strategy strategy) {
this.name = name;
this.strategy = strategy;
}
/**
* 策略决定下一局要出的手势
*
* @return
*/
public Hand nextHand() {
return strategy.nextHand();
}
/**
* 猜拳胜利
*/
public void win() {
strategy.study(true);
wincount++;
gamecount++;
}
/**
* 猜拳失败
*/
public void lose() {
strategy.study(false);
losecount++;
gamecount++;
}
/**
* 猜拳平局
*/
public void even() {
gamecount++;
}
public String toString() {
return "[" + name + ":" + gamecount + " games, " + wincount + " win, " + losecount + " lose" + "]";
}
}
【主类】
package com.test.strategy.Sample;
public class Main {
public static void main(String[] args) {
// 让选手分别使用两种策略来比试
Player player1 = new Player("Taro", new WinningStrategy(314));
Player player2 = new Player("Hana", new ProbStrategy(12));
for (int i = 0; i < 10000; i++) {
Hand nextHand1 = player1.nextHand();
Hand nextHand2 = player2.nextHand();
if (nextHand1.isStrongerThan(nextHand2)) {
// System.out.println("Winner:" + player1);
player1.win();
player2.lose();
} else if (nextHand2.isStrongerThan(nextHand1)) {
// System.out.println("Winner:" + player2);
player1.lose();
player2.win();
} else {
// System.out.println("Even...");
player1.even();
player2.even();
}
}
System.out.println("Total result:");
System.out.println(player1.toString());
System.out.println(player2.toString());
}
}
【运行】
Total result:
[Taro:10000 games, 3107 win, 3617 lose]
[Hana:10000 games, 3617 win, 3107 lose]
Process finished with exit code 0
问答
如果需要增加一个随机出手势的策略，需要怎么实现
答：在nextHand方法中使用随机数即可，因为全部都是随机的，不需要学习之前的经验，因此study方法可以是空方法
在示例程序中，Hand类的fight方法负责判断平局。在进行判断时，它使用的表达式不是
this.handValue == h.value，而是this==h，请问为什么可以这样写?
答：因为使用了单例模式，只有三个手势实例，如果两个手势的handValue相同，说明两个实例就是同一个实例
编写Winningstrategy类时，won 字段的定义不是
private boolean won = false;而是写成了如下这样private boolean won;虽然写法不同，但是两者的运行结果一样，为什么？
答：因为全局变量如果没有被赋值就会被自动初始化：boolean类型默认是false；数值类型默认是0；引用类型默认是null。注意，局部变量不会被自动初始化
策略模式在JDK源码中的使用
简单来说，就是在排序的时候，可以指定不同的排序策略
package com.atguigu.jdk;
import java.util.Arrays;
import java.util.Comparator;
public class Strategy {
public static void main(String[] args) {
// TODO Auto-generated method stub
//数组
Integer[] data = {9, 1, 2, 8, 4, 3};
// 实现降序排序，返回-1放左边，1放右边，0保持不变
// 说明
// 1. 实现了 Comparator 接口（策略接口） , 匿名类对象：new Comparator(){..}
// 2. 对象 new Comparator(){..} 就是实现了 策略接口 的对象
// 3. public int compare(Integer o1, Integer o2){} 指定具体的处理策略
Comparator<Integer> comparator = new Comparator<Integer>() {
public int compare(Integer o1, Integer o2) {
if (o1 > o2) {
return -1;
} else {
return 1;
}
}
};
// sort源码说明 传入数字和一个排序策略
/*
* public static void sort(T[] a, Comparator c) {
if (c == null) {
sort(a); //默认方法
} else {
if (LegacyMergeSort.userRequested)
legacyMergeSort(a, c); //使用策略对象c
else
// 使用策略对象c
TimSort.sort(a, 0, a.length, c, null, 0, 0);
}
}
*/
// 方式1
Arrays.sort(data, comparator);
// 降序排序
System.out.println(Arrays.toString(data));
//方式2- 同时lambda 表达式实现 策略模式
Integer[] data2 = {19, 11, 12, 18, 14, 13};
// 换一个排序策略
Arrays.sort(data2, (var1, var2) -> {
if (var1.compareTo(var2) > 0) {
return -1;
} else {
return 1;
}
});
System.out.println("data2=" + Arrays.toString(data2));
}
}
总结
【说明】
- 策略模式的关键是分析项目中变化部分与不变部分
【优点】
- 策略模式的核心思想是：多用组合/聚合，少用继承；用行为类来组合，而不是行为的继承
- 体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略 (或者行为)即可，避免了使用多重判断语句 (if…else if…else)
- 提供了可以替换继承关系的办法: 策略模式将算法封装在独立的Strategy类中使得你可以独立于其他Context改变它，使它易于切换、易于理解、易于扩展
- 程序运行过程中也可以切换策略：如果使用Strategy模式，在程序运行中也可以切换ConcreteStrategy角色。如在内存较少的环境使用一种算法，内存较多的环境使用另外一种算法
【缺点】
- 每添加一个策略就要增加一个类，当策略过多是会导致类数目庞大
【问答】
为什么需要特意编写Strategy角色
答：当我们想要通过改善算法来提高算法的处理速度时，如果使用了Strategy模式，就不必修改Strategy角色的接口(API)了，仅仅修改ConcreteStrategy角色即可。而且，使用委托这种弱关联关系可以很方便地整体替换算法，这样也更加方便算法的比较