设计模式-【策略模式】

【策略模式应用场景举例】
    比如在玩“极品飞车”这款游戏，那么游戏对车的轮胎是可以更换的，不同的轮胎在高速转弯时有不同的痕迹样式，那么针对“汽车”的配件“轮胎”就要可以变化，而且轮胎和轮胎之间是可以相互替换的，这就是典型的要应用“策略模式”的场景！从程序结构中可以看到，完全符合了前面我们的要求：“灵活”，“顺序敏感”。

【策略模式解释】
    类型：行为模式
    定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。策略模式使这些算法在客户端调用它们的时候能够互不影响地变化。

【策略模式UML图】


【策略模式-JAVA代码实现】
从策略模式UML图中可以看到Context与接口Strategy是组合关系，即强引用关系。
新建一个轮胎接口：

1. package strategy_interface;
   
2. public interface tyre_interface {
   
3.     // tyre 轮胎
   
4.     public void print_tyre_line();// 显示出轮胎的痕迹
   
5. }

复制代码

新建2个轮胎接口的实现类：

1. package strategy_implement;
   
2. import strategy_interface.tyre_interface;
   
3. //长痕迹轮胎类
   
4. public class tyre_long_implement implements tyre_interface {
   
5.     public void print_tyre_line() {
   
6.         System.out.println("在路面上显示一个长轮胎痕迹");
   
7.     }
   
8. }

复制代码

1. package strategy_implement;
   
2. import strategy_interface.tyre_interface;
   
3. //短痕迹轮胎类
   
4. public class tyre_short_implement implements tyre_interface {
   
5.     public void print_tyre_line() {
   
6.         System.out.println("在路面上显示一个短轮胎痕迹");
   
7.     }
   
8. }

复制代码

基于一个轮胎接口来实现不同样式的轮胎样式。
组装一个Car车类：

1. package car_package;
   
2. import strategy_interface.tyre_interface;
   
3. public class Car {
   
4.     private String make_address;// 制造地
   
5.     private int death_year;// 报废年限
   
6.     private int speed;// 速度
   
7.     private tyre_interface tyre_interface_ref;// 轮胎的样式
   
8.     public String getMake_address() {
   
9.         return make_address;
   
10.     }
    
11.     public void setMake_address(String make_address) {
    
12.         this.make_address = make_address;
    
13.     }
    
14.     public int getDeath_year() {
    
15.         return death_year;
    
16.     }
    
17.     public void setDeath_year(int death_year) {
    
18.         this.death_year = death_year;
    
19.     }
    
20.     public int getSpeed() {
    
21.         return speed;
    
22.     }
    
23.     public void setSpeed(int speed) {
    
24.         this.speed = speed;
    
25.     }
    
26.     public tyre_interface getTyre_interface_ref() {
    
27.         return tyre_interface_ref;
    
28.     }
    
29.     public void setTyre_interface_ref(tyre_interface tyre_interface_ref) {
    
30.         this.tyre_interface_ref = tyre_interface_ref;
    
31.     }
    
32.     public void start() {
    
33.         System.out.println("车的基本信息为：");
    
34.         System.out.println("制造地make_address：" + this.getMake_address());
    
35.         System.out.println("报废年限death_year：" + this.getDeath_year());
    
36.         System.out.println("速度speed：" + this.getSpeed());
    
37. 
    
38.         System.out.println("Car 起动了！");
    
39. 
    
40.         System.out.println("Car高速行驶，遇到一个大转弯，路面显示：");
    
41.         this.getTyre_interface_ref().print_tyre_line();
    
42.     }
    
43. }

复制代码

让车跑起来，并且具有更换轮胎样式的功能：

1. package main_run;
   
2. import strategy_implement.tyre_long_implement;
   
3. import strategy_implement.tyre_short_implement;
   
4. import car_package.Car;
   
5. public class run_main {
   
6.     public static void main(String[] args) {
   
7.         tyre_long_implement tyre_long_implement = new tyre_long_implement();
   
8.         tyre_short_implement tyre_short_implement = new tyre_short_implement();
   
9.         Car car = new Car();
   
10.         car.setDeath_year(8);
    
11.         car.setMake_address("北京朝阳区");
    
12.         car.setSpeed(200);
    
13.         car.setTyre_interface_ref(tyre_long_implement);
    
14.         car.start();
    
15.     }
    
16. }

复制代码

控制台打印出：

1. 车的基本信息为：
   
2. 制造地make_address：北京朝阳区
   
3. 报废年限death_year：8
   
4. 速度speed：200
   
5. Car 起动了！
   
6. Car高速行驶，遇到一个大转弯，路面显示：
   
7. 在路面上显示一个长轮胎痕迹

复制代码

是一个长轮胎痕迹，但在程序中可以使用代码：car.setTyre_interface_ref（tyre_long_implement）；来对轮胎的样式进行不同的替换，可以替换成短轮胎痕迹的汽车轮胎，这样在不更改Car类的前题下进行了不同轮胎样式的改变，轮胎和轮胎之间可以互相替换，这就是策略模式。

策略模式：

虽然看不懂,但值得收藏!