【策略模式应用场景举例

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

    【策略模式解释

    类型:行为模式

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

    【策略模式UML图

    【策略模式-JAVA代码实现

    从策略模式UML图中可以看到Context与接口Strategy是组合关系,即强引用关系。

    新建一个轮胎接口:

 

package strategy_interface;
public interface tyre_interface {
    
// tyre 轮胎
    public void print_tyre_line();// 显示出轮胎的痕迹
}

 

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

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

 

package strategy_implement;
import strategy_interface.tyre_interface;
//短痕迹轮胎类
public class tyre_short_implement implements tyre_interface {
    
public void print_tyre_line() {
        System.out.println(
"在路面上显示一个短轮胎痕迹");
    }
}
  基于一个轮胎接口来实现不同样式的轮胎样式。

    组装一个Car车类:

package car_package;
import strategy_interface.tyre_interface;
public class Car {
    
private String make_address;// 制造地
    private int death_year;// 报废年限
    private int speed;// 速度
    private tyre_interface tyre_interface_ref;// 轮胎的样式
    
public String getMake_address() {
        
return make_address;
    }
    
public void setMake_address(String make_address) {
        
this.make_address = make_address;
    }
    
public int getDeath_year() {
        
return death_year;
    }
    
public void setDeath_year(int death_year) {
        
this.death_year = death_year;
    }
    
public int getSpeed() {
        
return speed;
    }
    
public void setSpeed(int speed) {
        
this.speed = speed;
    }
    
public tyre_interface getTyre_interface_ref() {
        
return tyre_interface_ref;
    }
    
public void setTyre_interface_ref(tyre_interface tyre_interface_ref) {
        
this.tyre_interface_ref = tyre_interface_ref;
    }
    
public void start() {
        System.out.println(
"车的基本信息为:");
        System.out.println(
"制造地make_address:" + this.getMake_address());
        System.out.println(
"报废年限death_year:" + this.getDeath_year());
        System.out.println(
"速度speed:" + this.getSpeed());

        System.out.println(
"Car 起动了!");

        System.out.println(
"Car高速行驶,遇到一个大转弯,路面显示:");
        
this.getTyre_interface_ref().print_tyre_line();
    }
}

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

 

package main_run;
import strategy_implement.tyre_long_implement;
import strategy_implement.tyre_short_implement;
import car_package.Car;
public class run_main {
    
public static void main(String[] args) {
        tyre_long_implement tyre_long_implement 
= new tyre_long_implement();
        tyre_short_implement tyre_short_implement 
= new tyre_short_implement();
        Car car 
= new Car();
        car.setDeath_year(
8);
        car.setMake_address(
"北京朝阳区");
        car.setSpeed(
200);
        car.setTyre_interface_ref(tyre_long_implement);
        car.start();
    }
}

 

    控制台打印出:

 

车的基本信息为:
制造地make_address:北京朝阳区
报废年限death_year:
8
速度speed:
200
Car 起动了!
Car高速行驶,遇到一个大转弯,路面显示:
在路面上显示一个长轮胎痕迹

 

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