策略模式
定义：定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。
应用场景：
1.多个类只有在算法或行为上稍有不同的场景。
2.算法需要自由切换的场景。
3.需要屏蔽算法规则的场景。
strategy.png
角色：
Context封装角色：屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化。
Strategy抽象策略角色：策略、算法家族的抽象，通常为接口，定义每个策略或算法必须具有的方法和属性。
ConcreteStrategy具体策略角色：实现抽象策略中的操作，该类含有具体的算法。
实现：
public class Price {
private int type;
public static final int TYPE_Primary = 1; //普通会员
public static final int TYPE_Intermediate = 2; //中级会员
public static final int TYPE_Advanced = 3; //高级会员
public void setType(int type){
this.type = type;
}
/**
* 计算图书的价格
*/
public double quote(double booksPrice){
if(type == TYPE_Primary){
System.out.println("对于初级会员的没有折扣");
return booksPrice;
} else if(type == TYPE_Intermediate){
System.out.println("对于中级会员的折扣为10%");
return booksPrice * 0.9;
} else if(type == TYPE_Advanced){
System.out.println("对于高级会员的折扣为20%");
return booksPrice * 0.8;
} else {
System.out.println("这是啥？？？");
return -1;
}
}
}
策略模式实现：
public interface MemberStrategy {
/**
* 计算图书的价格
* @param booksPrice 图书的原价
* @return 计算出打折后的价格
*/
public double calcPrice(double booksPrice);
}
public class PrimaryMemberStrategy implements MemberStrategy {
@Override
public double calcPrice(double booksPrice) {
System.out.println("对于初级会员的没有折扣");
return booksPrice;
}
}
public class IntermediateMemberStrategy implements MemberStrategy {
@Override
public double calcPrice(double booksPrice) {
System.out.println("对于中级会员的折扣为10%");
return booksPrice * 0.9;
}
}
public class AdvancedMemberStrategy implements MemberStrategy {
@Override
public double calcPrice(double booksPrice) {
System.out.println("对于高级会员的折扣为20%");
return booksPrice * 0.8;
}
}
public class Price {
//持有一个具体的策略对象
private MemberStrategy strategy;
public setMemberStrategy(MemberStrategy strategy){
this.strategy = strategy;
}
/**
* 计算图书的价格
*/
public double quote(double booksPrice){
return this.strategy.calcPrice(booksPrice);
}
}
策略模式的优点：
算法可以自由切换
避免使用多重条件判断
扩展性良好
策略模式的缺点:
策略类数量增多
所有的策略类都需要对外暴露
状态模式
定义：当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类。
应用场景：
1.行为随状态改变而改变的场景。
2.条件、分支判断语句的替代者。
state.png
角色：
State抽象状态角色：接口或抽象类，负责对象状态定义，并且封装环境角色以实现状态切换。
ConcreteState具体状态角色：本状态下要做的事情。
Context环境角色：定义客户端需要的接口，并且负责具体状态的切换。
public interface MemberState {
/**
* 计算图书的价格
* @param booksPrice 图书的原价
* @return 计算出打折后的价格
*/
public void buyBook(double booksPrice);
}
public class PrimaryMemberState implements MemberState {
@Override
public void buyBook(double booksPrice) {
System.out.println("对于初级会员的没有折扣" + booksPrice);
}
}
public class IntermediateMemberState implements MemberState {
@Override
public void buyBook(double booksPrice) {
System.out.println("对于中级会员的折扣为10%" + booksPrice * 0.9);
}
}
public class AdvancedMemberState implements MemberState {
@Override
public void buyBook(double booksPrice) {
System.out.println("对于高级会员的折扣为20%"+ booksPrice * 0.8);
}
}
public class Person {
//持有一个具体的策略对象
private MemberState state;
public setMemberStrategy(MemberState state){
this.state = state;
}
/**
* 买一本书
*/
public void buyBook(double booksPrice){
this.state.buyBook(booksPrice);
}
}
策略模式vs状态模式：
问题的重点是业务关注的是什么，是状态还是工作逻辑？找准了业务的焦点，才能选择一个好的设计模式。
解决问题的重点不同：
策略模式旨在解决内部算法如何改变的问题，也就是将内部算法的改变对外界的影响降低到最小，它保证的是算法可以自由地切换；
而状态模式旨在解决内在状态的改变而引起行为改变的问题，它的出发点是事物的状态，封装状态而暴露行为，一个对象的状态改变，从外界来看就好像是行为改变。
