策略模式
为了防止被“杀”了祭天，学点设计模式，并总结下还是有必要的。
一：理解
- 对象包含策略，可以根据不同对象的策略，执行不同的操作。
- 就像店家给不同等级的会员不同的折扣，其实是用不同的策略来为客户服务。
- 策略模式和行为模式类似。
二：例子
你是个富二代，你有很多朋友。
今天，你要在家宴请自己的好朋友。由于朋友太多，你记不全，但又希望给对方一种很亲密的感觉，和每个来宾都打招呼。
大型派对
于是你叫来了程序员小菜帮你解决这个打招呼问题。
小菜一来就新建一个朋友类，朋友有名字属性。
@Data
public class Friend {
private String name;
public Friend(String name) {
this.name = name;
}
}
为了方便记忆，你让小菜把把朋友分成四类，分别是：
- 普通朋友
- 前女友
- 领导
- 老板
小菜分别为每类朋友建立了对应的类。
// 普通朋友
public class OrdinaryFriend extends Friend {
public OrdinaryFriend(String name) {
super(name);
}
}
// 前女友
public class ExGirlFriend extends Friend {
public ExGirlFriend(String name) {
super(name);
}
}
// 领导
public class Leader extends Friend {
public Leader(String name) {
super(name);
}
}
// 老板
public class Boss extends Friend {
public Boss(String name) {
super(name);
}
}
今晚，你将用不同的方式和不同类的朋友打招呼。
小菜帮你设计的程序使用if else来判断来宾的类别，并输出不同的打招呼语句。
看了小菜写的代码，你觉得没什么问题，而且还用到了instanceof这个你没见过的运算符，觉得小菜还是可以委以重任的。
public class Client {
public static void main(String[] args) {
System.out.println("派对开始,开始和来宾寒暄!");
OrdinaryFriend ordinaryFriend = new OrdinaryFriend("Peter");
greet(ordinaryFriend);
ExGirlFriend exGirlFriend = new ExGirlFriend("Mary");
greet(exGirlFriend);
Leader leader = new Leader("Obama");
greet(leader);
Boss boss = new Boss("Jack");
greet(boss);
}
public static void greet(Friend friend) {
if (friend instanceof OrdinaryFriend) {
System.out.println("等着对方打招呼,就是这么高贵,优雅!");
} else if (friend instanceof ExGirlFriend) {
System.out.println(friend.getName() + ",你是不是还是放不下我?");
} else if (friend instanceof Leader) {
System.out.println("尊敬的" + friend.getName() + ",您好!");
} else if (friend instanceof Boss) {
System.out.println("尊敬的" + friend.getName() + ",您好!");
}
}
}
派对开始,开始和来宾寒暄!
等着对方打招呼,就是这么高贵,优雅!
Mary,你是不是还是放不下我?
尊敬的Obama,您好!
尊敬的Jack,您好!
派对顺利地结束了，你和每位来宾都打了招呼。
然而，随着你的生意越做越大，朋友越来越多，地位也越来越高，你需要时不时地添加和修改打招呼的方法。
于是，程序员小菜再一次徜徉在修改if else的海洋中。
小菜想，如果为每个朋友发一张身份卡，挂在胸前，主人看到身份卡就能知道该如何打招呼。
于是，小菜将打招呼程序进行重构，为每个朋友发了一张身份卡，即greet方法。
@Data
public abstract class Friend {
private String name;
public Friend(String name) {
this.name = name;
}
public abstract void greet();
}
Friend基类变成了抽象类，申明了greet方法，具体实现交给子类。
// 普通朋友
public class OrdinaryFriend extends Friend {
public OrdinaryFriend(String name) {
super(name);
}
@Override
public void greet() {
System.out.println("等着对方打招呼,就是这么高贵,优雅!");
}
}
// 前女友
public class ExGirlFriend extends Friend {
public ExGirlFriend(String name) {
super(name);
}
@Override
public void greet() {
System.out.println(getName() + ",你是不是还是放不下我?");
}
}
// 领导
public class Leader extends Friend {
public Leader(String name) {
super(name);
}
@Override
public void greet() {
System.out.println("尊敬的" + getName() + ",您好!");
}
}
// 老板
public class Boss extends Friend {
public Boss(String name) {
super(name);
}
@Override
public void greet() {
System.out.println("尊敬的" + getName() + ",您好!");
}
}
打招呼时直接调用来宾的greet方法即可。
public class Client {
public static void main(String[] args) {
System.out.println("派对开始,开始和来宾寒暄!");
OrdinaryFriend ordinaryFriend = new OrdinaryFriend("Peter");
greet(ordinaryFriend);
ExGirlFriend exGirlFriend = new ExGirlFriend("Mary");
greet(exGirlFriend);
Leader leader = new Leader("Obama");
greet(leader);
Boss boss = new Boss("Jack");
greet(boss);
}
// 直接调用来宾的greet方法即可
public static void greet(Friend friend) {
friend.greet();
}
}
为了更加精细地管理自己的朋友圈，你将自己的朋友圈分组表发给了小菜。
并且你最近学了英语，希望和某一类朋友(领导/老板等)打招呼的时候，使用英语。
小菜发现，虽然你的朋友类别增加到了一百类，但打招呼的方式只有固定不变的三种。
例子中和领导老板打招呼的方式一样，将打招呼方式修改成英语时，需要修改多个类的greet方法。
小菜整理了打招呼的策略，整理出三种：
- 装作没看到策略，NoSeeStrategy
- 前女友后悔策略，ExStrategy
- 尊敬策略，RespectStrategy
于是，小菜采用策略模式，提取出一个策略接口，申明了greet方法。
并实现了三种打招呼策略类。
// 招呼策略接口
public interface GreetStrategy {
void greet();
}
// 装作没看到策略
public class NoSeeStrategy implements GreetStrategy {
@Override
public void greet() {
System.out.println("等着对方打招呼,就是这么高贵,优雅!");
}
}
// 前女友后悔策略
public class ExStrategy implements GreetStrategy {
@Override
public void greet() {
System.out.println("你是不是还是放不下我?");
}
}
// 尊敬策略
public class RespectStrategy implements GreetStrategy {
@Override
public void greet() {
System.out.println("尊敬的客人, 您好!");
}
}
修改朋友类，为朋友加上GreetStrategy属性。
在普通朋友的构造器中，直接set装作没看见策略NoSeeStrategy。
其他几类类似，不再给出。
@Data
public class Friend {
private String name;
private GreetStrategy greetStrategy;
public Friend(String name) {
this.name = name;
}
public void greet() {
greetStrategy.greet();
}
}
// 普通朋友类
public class OrdinaryFriend extends Friend {
// 在构造器中，直接setGreetStrategy
public OrdinaryFriend(String name) {
super(name);
setGreetStrategy(new NoSeeStrategy());
}
}
和朋友打招呼时，其实调用的是打招呼策略的greet方法。
用了策略模式之后，修改和领导/老板打招呼的方法时，不用再同时修改两个类，只需修改RespectStrategy即可。
public class RespectStrategy implements GreetStrategy {
@Override
public void greet() {
System.out.println("Dear guests, nice to meet you!");
}
}
于是，小菜开心地下班了。
下班了
三：再理解
- 策略模式是对继承体系的一种再思考。继承体系中，使用重写来表示不同子类的不同策略，这些策略往往会重复，提取这些策略，并新建对应的策略类。
- 策略模式可以避免多次修改，也可以很方便地新增新的策略。
- 由于朋友子类中的setGreetStrategy是public的，可以临场修改打招呼的策略，将新的策略set进去即可。
- 策略模式也称为行为模式，只是分析问题的角度不一样。
- 行为模式例子：你是个富二代，你有十类女友，包括娇小型，淑女型，熟女型等，她们都有papapa的行为，但精通的姿势不一样。由于你的女友实在太多，每次papapa的时候，你需要在脑子里执行n多个if else，才能决定使用哪种姿势。于是你决定让每个女友都自带papapa()方法，在成长的时候，直接调用女友的papapa方法即可。和打招呼一样，你发现虽然你有十类女友，但她们papapa的姿势只有三种，分别是姿势A，姿势B和姿势C，于是你抽象出了三种PapapaBehavior，女友们都持有PapapaBehavior对象。每次你想开发新的papapa姿势时，不用再修改多个女友类，只需新增一个papapa行为类即可。
- 不同的papapa姿势对于你而言是策略，而对于女朋友们而言是行为。
