策略模式，顧名思義，就是在一個問題有多種解決方法的時候應用哪種方法，哪種策略來完成而設計的一種模式，以達到高解耦，靈活性高，代碼更加清晰明了。策略模式又是一種面向對象的設計模式，說白了，所有的這些模式的出現都是為了使程序或者代碼結構更加清晰，易于理解，降低耦合性，提高靈活性以使代碼更加容易擴展等等。
定義：策略模式定義了一系列算法，并將每個算法封裝起來，而且使得它們可以相互替換，策略模式讓算法和使用它的客戶端而獨立變化。
策略模式的使用場景：
1.
針對一個問題有多種解決方法的時候，用來選擇具體的哪種方法。
1.
將多種同類型的操作獨立封裝起來， 保證多種同類型的操作安全性。當我們的程序有多種同類型的方法時我們不應該因為添加了新類型的方法而要改變原來的方法，不然就違背了OCP（開閉）原則和單一職責原則。
1.
擺脫臃腫。當出現同一個類有多個子類時選擇哪個子類而不需要if-else或者switch-else。
策略模式的優點：
1.
結構清晰明了，使用簡單直觀。使用時根據需要選擇不同的策略；
1.
耦合度較低，靈活性高，易擴展；
1.
操作（策略）封裝比較徹底，數據更加安全。
策略模式的缺點：
- 隨著策略數量增加的增加，需要的策略子類越來越多，程序體積變大。
策略模式的實現：
路線情況：
~~~
/**
* 乘車的路線情況
* @author lt
*
*/
public class Route {
public String type; // 路的類型，如：水路
public int money; // 消耗的路費
public String time; // 花費的時間
@Override
public String toString() {
return "Route [type=" + type + ", money=" + money + ", time=" + time
+ "]";
}
}
~~~
抽象乘車策略類：
~~~
/**
* 乘車策略
* @author lt
*
*/
public abstract class RideStrategy {
/**
* 計算乘車價格
* @return
*/
public abstract Route CalcuRidePrice();
}
~~~
走水路:
~~~
/**
* 水路，這是一種策略
* @author Administrator
*
*/
public class Waterway extends RideStrategy {
@Override
public Route CalcuRidePrice() {
Route route = new Route();
route.type = "水路";
route.money = 100;
route.time = "2個小時";
return route;
}
}
~~~
走陸路:
~~~
/**
* 陸路，這是一種策略
* @author lt
*
*/
public class Randway extends RideStrategy {
@Override
public Route CalcuRidePrice() {
Route route = new Route();
route.type = "陸路";
route.money = 180;
route.time = "1個半小時";
return route;
}
}
~~~
走空路：
~~~
/**
* 空路，乘飛機，這是一種策略
* @author lt
*
*/
public class Airway extends RideStrategy {
@Override
public Route CalcuRidePrice() {
Route route = new Route();
route.type = "空路";
route.money = 400;
route.time = "20分鐘";
return route;
}
}
~~~
乘車：
~~~
/**
* 乘車
* @author lt
*
*/
public class Ride {
private RideStrategy rideStrategy;
/**
* 獲取路線情況
* @return
*/
public Route getRoute(){
return rideStrategy.CalcuRidePrice();
}
public RideStrategy getRideStrategy() {
return rideStrategy;
}
public void setRideStrategy(RideStrategy rideStrategy) {
this.rideStrategy = rideStrategy;
}
}
~~~
測試使用這三種策略：
~~~
public class Test {
public static void main(String[] args) {
Ride ride = new Ride();
// 1. 走水路
ride.setRideStrategy(new Waterway());
System.out.println(ride.getRoute());
// 2. 走陸路
ride.setRideStrategy(new Randway());
System.out.println(ride.getRoute());
// 3. 走空路
ride.setRideStrategy(new Airway());
System.out.println(ride.getRoute());
}
}
~~~
結果：
可以看到，上面我們測試的方法里面這三種策略只是換了一個實現而已，源碼什么了都沒修改，僅僅改變了策略，這就實現了這三種策略的使用。而且以后如果各路線的情況改變了，比如水路漲價了，那么我們只需要修改水路那種策略，即：只要修改Waterway.java這個類而不用修改其他策略（陸路和空路），保證了其他策略（陸路和空路）的安全，并且以后如果有其他種類的路線（除了海陸空），那么相應的只需要增加一個策略類而已，極易擴展和使用。
總結：
策略模式的引入使得我們的程序結構更加清晰明了，耦合性降低，靈活性提升，在面對實際的一個操作有多種算法或者策略實現的情況下應多使用這種模式。
