1、策略模式概念
1.1 介紹
在策略模式（Strategy Pattern）中，一個類的行為或其算法可以在運行時更改。這種類型的設計模式屬于行為型模式。
在策略模式中，我們創建表示各種策略的對象和一個行為隨著策略對象改變而改變的 context 對象。策略對象改變 context 對象的執行算法。
1.2 定義
也叫作政策模式，定義一組算法，將每個算法都封裝起來，并且使他們之間可以互換!
1.3 使用場景
- 如果在一個系統里面有許多類，它們之間的區別僅在于它們的行為，那么使用策略模式可以動態地讓一個對象在許多行為中選擇一種行為。
- 一個系統需要動態地在幾種算法中選擇一種。
- 如果一個對象有很多的行為，如果不用恰當的模式，這些行為就只好使用多重的條件選擇語句來實現。
2、策略模式UML類圖
策略模式UML類圖
角色如下：
策略接口（Strategy）：策略是一個接口，該接口定義若干個算法標識，即定義了若干個抽象方法。
具體策略（ConcreteStrategy）：具體策略是實現策略接口的類。具體策略實現策略接口所定義的抽象方法，即給出算法標識的具體算法。
上下文（Context）：上下文是依賴于策略接口的類，即上下文包含有策略聲明的變量。上下文中提供了一個方法，該方法委托策略變量調用具體策略所實現的策略接口中的方法。
3、策略模式實現
案例：不同公司理財產品政策
Strategy：
public interface IManageFinancy {
/**
* 理財算法
* @param month
* @param money
* @return
*/
public float manageFinancy(int month, float money);
}
ConcreteStrategy：
public class PingAnManageFinanacy implements IManageFinancy {
@Override
public float manageFinancy(int month, float money) {
if (month == 6) {
return money + money * 0.08f / 12 * 6;
} else if (month == 12) {
return money + money * 0.09f / 12 * 12;
} else {
throw new IllegalArgumentException("親您好，沒有你要的理財產品！");
}
}
}
public class YouLiWangManageFinancy implements IManageFinancy {
@Override
public float manageFinancy(int month, float money) {
if (month == 3) {
return money + money * 0.07f / 12 * 3;
} else if (month == 6) {
return money + money * 0.08f / 12 * 6;
} else if (month == 12) {
return money + money * 0.095f / 12 * 12;
} else if (month == 24) {
return money + money * 0.105f / 12 * 24;
} else {
throw new IllegalArgumentException("您輸入的月份，沒有對應的理財產品！");
}
}
}
public class ZhiFuBaoManageFinancy implements IManageFinancy {
@Override
public float manageFinancy(int month, float money) {
if (month == 6) {
return money + money * 0.03f / 12 * 6;
} else if (month == 12) {
return money + money * 0.04f / 12 * 12;
} else if (month == 24) {
return money + money * 0.045f / 12 * 24;
} else {
throw new IllegalArgumentException("您輸入的月份，沒有對應的理財產品！");
}
}
}
Context：
public class ManangeFinancyContext {
private IManageFinancy manageFinancy;
public ManangeFinancyContext(IManageFinancy manageFinancy) {
this.manageFinancy = manageFinancy;
}
public float manageFinancy(int month,float money){
return this.manageFinancy.manageFinancy(month, money);
}
}
Client：
public class Client {
public static void main(String[] args) {
IManageFinancy manageFinancy = new ZhiFuBaoManageFinancy();
ManangeFinancyContext financyContext = new ManangeFinancyContext(
manageFinancy);
float money = financyContext.manageFinancy(12, 10000);
System.out.println("理財之后的金額：" + money);
}
}
結果輸出：
理財之后的金額：10400.0
4、策略模式Android場景分析
而在Android的系統源碼中,策略模式也是應用的相當廣泛的.最典型的就是屬性動畫中的應用.
我們知道,在屬性動畫中,有一個東西叫做插值器,它的作用就是根據時間流逝的百分比來來計算出當前屬性值改變的百分比.
我們使用屬性動畫的時候,可以通過set方法對插值器進行設置.可以看到內部維持了一個時間插值器的引用，并設置了getter和setter方法，默認情況下是先加速后減速的插值器，set方法如果傳入的是null，則是線性插值器。而時間插值器TimeInterpolator是個接口，有一個接口繼承了該接口，就是Interpolator這個接口，其作用是為了保持兼容
private static final TimeInterpolator sDefaultInterpolator =
new AccelerateDecelerateInterpolator();
private TimeInterpolator mInterpolator = sDefaultInterpolator;
@Override
public void setInterpolator(TimeInterpolator value) {
if (value != null) {
mInterpolator = value;
} else {
mInterpolator = new LinearInterpolator();
}
}
@Override
public TimeInterpolator getInterpolator() {
return mInterpolator;
}
public interface Interpolator extends TimeInterpolator {
// A new interface, TimeInterpolator, was introduced for the new android.animation
// package. This older Interpolator interface extends TimeInterpolator so that users of
// the new Animator-based animations can use either the old Interpolator implementations or
// new classes that implement TimeInterpolator directly.
}
此外還有一個BaseInterpolator插值器實現了Interpolator接口，并且是一個抽象類
abstract public class BaseInterpolator implements Interpolator {
private int mChangingConfiguration;
/**
* @hide
*/
public int getChangingConfiguration() {
return mChangingConfiguration;
}
/**
* @hide
*/
void setChangingConfiguration(int changingConfiguration) {
mChangingConfiguration = changingConfiguration;
}
}
平時我們使用的時候，通過設置不同的插值器，實現不同的動畫速率變換效果，比如線性變換，回彈，自由落體等等。這些都是插值器接口的具體實現，也就是具體的插值器策略。我們略微來看幾個策略。
public class LinearInterpolator extends BaseInterpolator implements NativeInterpolatorFactory {
public LinearInterpolator() {
}
public LinearInterpolator(Context context, AttributeSet attrs) {
}
public float getInterpolation(float input) {
return input;
}
/** @hide */
@Override
public long createNativeInterpolator() {
return NativeInterpolatorFactoryHelper.createLinearInterpolator();
}
}
public class AccelerateDecelerateInterpolator extends BaseInterpolator
implements NativeInterpolatorFactory {
public AccelerateDecelerateInterpolator() {
}
@SuppressWarnings({"UnusedDeclaration"})
public AccelerateDecelerateInterpolator(Context context, AttributeSet attrs) {
}
public float getInterpolation(float input) {
return (float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5f;
}
/** @hide */
@Override
public long createNativeInterpolator() {
return NativeInterpolatorFactoryHelper.createAccelerateDecelerateInterpolator();
}
}
內部使用的時候直接調用getInterpolation方法就可以返回對應的值了，也就是屬性值改變的百分比。
屬性動畫中另外一個應用策略模式的地方就是估值器，它的作用是根據當前屬性改變的百分比來計算改變后的屬性值。該屬性和插值器是類似的，有幾個默認的實現。其中TypeEvaluator是一個接口。
public interface TypeEvaluator<T> {
public T evaluate(float fraction, T startValue, T endValue);
}
public class IntEvaluator implements TypeEvaluator<Integer> {
public Integer evaluate(float fraction, Integer startValue, Integer endValue) {
int startInt = startValue;
return (int)(startInt + fraction * (endValue - startInt));
}
}
public class FloatEvaluator implements TypeEvaluator<Number> {
public Float evaluate(float fraction, Number startValue, Number endValue) {
float startFloat = startValue.floatValue();
return startFloat + fraction * (endValue.floatValue() - startFloat);
}
}
public class PointFEvaluator implements TypeEvaluator<PointF> {
private PointF mPoint;
public PointFEvaluator() {
}
public PointFEvaluator(PointF reuse) {
mPoint = reuse;
}
@Override
public PointF evaluate(float fraction, PointF startValue, PointF endValue) {
float x = startValue.x + (fraction * (endValue.x - startValue.x));
float y = startValue.y + (fraction * (endValue.y - startValue.y));
if (mPoint != null) {
mPoint.set(x, y);
return mPoint;
} else {
return new PointF(x, y);
}
}
}
public class ArgbEvaluator implements TypeEvaluator {
private static final ArgbEvaluator sInstance = new ArgbEvaluator();
public static ArgbEvaluator getInstance() {
return sInstance;
}
public Object evaluate(float fraction, Object startValue, Object endValue) {
int startInt = (Integer) startValue;
int startA = (startInt >> 24) & 0xff;
int startR = (startInt >> 16) & 0xff;
int startG = (startInt >> 8) & 0xff;
int startB = startInt & 0xff;
int endInt = (Integer) endValue;
int endA = (endInt >> 24) & 0xff;
int endR = (endInt >> 16) & 0xff;
int endG = (endInt >> 8) & 0xff;
int endB = endInt & 0xff;
return (int)((startA + (int)(fraction * (endA - startA))) << 24) |
(int)((startR + (int)(fraction * (endR - startR))) << 16) |
(int)((startG + (int)(fraction * (endG - startG))) << 8) |
(int)((startB + (int)(fraction * (endB - startB))));
}
}
其它案例
1.網絡框架中的緩存策略（內存緩存和硬盤緩存）
2.文件、圖片命名策略
3.文件、網絡請求加密算法策略
以文件、圖片命名策略為例
FileNameGenerator ---> 類似于策略接口
Md5FileNameGenerator、HashCodeFileNameGenerator---> 類似于策略實現類
public interface FileNameGenerator {
/** Generates unique file name for image defined by URI */
String generate(String imageUri);
}
public class HashCodeFileNameGenerator implements FileNameGenerator {
@Override
public String generate(String imageUri) {
return String.valueOf(imageUri.hashCode());
}
}
public class Md5FileNameGenerator implements FileNameGenerator {
private static final String HASH_ALGORITHM = "MD5";
private static final int RADIX = 10 + 26; // 10 digits + 26 letters
@Override
public String generate(String imageUri) {
byte[] md5 = getMD5(imageUri.getBytes());
BigInteger bi = new BigInteger(md5).abs();
return bi.toString(RADIX);
}
private byte[] getMD5(byte[] data) {
byte[] hash = null;
try {
MessageDigest digest = MessageDigest.getInstance(HASH_ALGORITHM);
digest.update(data);
hash = digest.digest();
} catch (NoSuchAlgorithmException e) {
}
return hash;
}
}
5、模式總結
5.1 優點
- 算法可以自由切換。
- 避免使用多重條件判斷。
- 擴展性良好。
5.2 缺點
- 策略類會增多。
- 所有策略類都需要對外暴露。
