Java设计模式之策略模式原理与用法实例详解

时间:2022-02-24 07:31:51

本文实例讲述了java设计模式策略模式原理与用法。分享给大家供大家参考,具体如下:

策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。其中jdk里面的treeset类和treemap类就用到了策略模式。这两个类是带排序的集合类,其中排序的规则就相当于策略模式里定义的一系列算法,而集合类就相当于是策略模式里的环境类,供用户使用,用只知道treeset和treemap是带排序的,至于怎么排序的,是由排序的算法决定的。

策略模式由三部分组成:抽象策略角色,具体策略角色,环境角色。

抽象策略角色:策略类,通常由一个接口或者抽象类实现。

具体策略角色:实现了抽象策略类,并包装了相关的算法和行为。

环境角色:持有一个策略类的引用,最终给客户端调用。

下面提供一个简单的策略模式的代码实例:

1.抽象策略角色:定义一个接口strategy。

?
1
2
3
4
5
6
7
8
9
package com.test;
/**
 * 策略模式抽象角色
 * @author zhouwen
 *
 */
public interface strategy {
  public int calculate(int a, int b);
}

2.具体策略角色:实现strategy接口。例子中是实现加减乘除的运算。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
package com.test;
/**
 * 策略模式具体策略类
 * 实现加法运算
 * @author zhouwen
 *
 */
public class addstrategy implements strategy {
  @override
  public int calculate(int a, int b) {
    return a + b;
  }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
package com.test;
/**
 * 策略模式具体策略类
 * 实现减法运算
 * @author zhouwen
 *
 */
public class subtractstrategy implements strategy {
  @override
  public int calculate(int a, int b) {
    return a - b;
  }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
package com.test;
/**
 * 策略模式具体策略类
 * 实现乘法运算
 * @author zhouwen
 *
 */
public class multiplystragety implements strategy {
  @override
  public int calculate(int a, int b) {
    return a * b;
  }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
package com.test;
/**
 * 策略模式具体策略类
 * 实现除法运算
 * @author zhouwen
 *
 */
public class dividestrategy implements strategy {
  @override
  public int calculate(int a, int b) {
    return a / b;
  }
}

3.环境角色:在环境角色中定义一个抽象角色的引用,并暴露出计算的方法,供客户端调用。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.test;
/**
 * 策略模式环境类
 * @author zhouwen
 *
 */
public class environment {
  private strategy strategy;
  public environment(strategy strategy){
    this.strategy = strategy;
  }
  //用以改变策略
  public void setstrategy(strategy strategy){
    this.strategy = strategy;
  }
  public strategy getstrategy(){
    return strategy;
  }
  //暴露计算的接口,供客户端调用
  public int calculate(int a, int b){
    return strategy.calculate(a, b);
  }
}

4.最后编写客户端的代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.test;
public class client {
  public static void main(string[] args) {
    addstrategy addstrategy = new addstrategy();
    environment environment = new environment(addstrategy);
    system.out.println(environment.calculate(3, 4));
    subtractstrategy substrategy = new subtractstrategy();
    environment.setstrategy(substrategy);
    system.out.println(environment.calculate(3, 4));
    multiplystragety multiplystrategy = new multiplystragety();
    environment.setstrategy(multiplystrategy);
    system.out.println(environment.calculate(3, 4));
    dividestrategy dividestrategy = new dividestrategy();
    environment.setstrategy(dividestrategy);
    system.out.println(environment.calculate(3, 4));
  }
}

总结:

由客户端的system.out.println(environment.calculate(3, 4));这句代码,我们并不知道具体调用的是哪个实现类,只有知道了传给环境角色的具体策略类我们才知道调用哪个类,这样就能实现客户端和具体策略算法的分离,使程序易于切换、易于理解、易于扩展。

策略模式的优缺点:

优点:

1.策略模式的用意是针对一组算法,将每一个算法封装到具有共同接口的独立的类中,从而使得他们可以相互替换。如提供的例子中通过set方法对策略进行替换。

2.策略模式使得算法可以在不影响客户端的情况下发生变化。使用策略模式可以把行为和环境分隔开。

3.环境类负责维持和查询行为类,各类算法则在具体策略中提供。由于算法和环境独立开来,算法的修改不会影响环境和客户端。

缺点:

1.客户端必须知道所有的策略类,并自行决定使用哪一个策略类。

2.会造成很多的策略类。

希望本文所述对大家java程序设计有所帮助。

原文链接:https://blog.csdn.net/zw19910924/article/details/41556493