策略模式

最新推荐文章于 2024-10-02 20:26:49 发布

rainyear

最新推荐文章于 2024-10-02 20:26:49 发布

阅读量470

点赞数

分类专栏：设计模式

本文链接：https://blog.youkuaiyun.com/rainyear/article/details/8855461

版权

设计模式专栏收录该内容

46 篇文章

订阅专栏

一．策略模式是对象的行为模式，用意是对一组算法的封装。动态的选择需要的算法并使用

一个接口，两个实现类1，2，一个client调用类，用于块定是调用类1还是类2.

UML示意图

二．组成部分：

1．环境角色:持有一个策略类引用

2．抽象策略

3．具体策略:相关的算法或操作

三．代码例子

1．抽象策略

package com.eekq.strategy;

public interface IStrategy {

/** 策略方法 */

public abstract double add();

}

2．具体策略，这里我以两个具体策略为例

package com.eekq.strategy;

public class ConcreteStrategy1 implements IStrategy {

/** 示意性算法 */

public double add() {

// TODO 自动生成方法存根

System. out .println( this .getClass().getName() + "的加法运算" );

return 0;

}

package com.eekq.strategy;

public class ConcreteStrategy2 implements IStrategy {

public double add() {

// TODO 自动生成方法存根

System. out .println( this .getClass().getName() + "的加法运算" );

return 0;

}

3.环境角色

package com.eekq.strategy;

public class Context {

/** 环境角色类 */

private IStrategy strategy ;

public Context(IStrategy strategy) {

this . strategy = strategy;

}

/** 策略方法 */

public double add() {

this . strategy .add();

return 0;

}

4.客户端调用

package com.eekq.strategy;

public class Main {

/**

* @param args

public static void main(String[] args) {

// TODO 自动生成方法存根

Context context = new Context( new ConcreteStrategy1());

context.add(); //执行算法1

context = new Context( new ConcreteStrategy2());

context.add(); //执行算法2

}

5.执行结果：

com.eekq.strategy.ConcreteStrategy1的加法运算

com.eekq.strategy.ConcreteStrategy2的加法运算

6.总结

优点：动态改变算法或行为

缺点:客户端必须知道所有的策略类，并自行决定使用哪一个策略类,必须对每一个算法了解

【策略模式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类的前题下进行了不同轮胎样式的改变，轮胎和轮胎之间可以互相替换，这就是策略模式。