策略模式

策略模式

案例引入

duck项目

要求：
1.有各种鸭子，比如野鸭，北京鸭，水鸭等，鸭子有各种行为，比如叫，飞行。
2.显示鸭子的信息。
传统方式实现案例

1.抽象一个父类duck，有其子类，野鸭、北京鸭、水鸭等。
代码

1. /**
2. * @author 长名06
3. * @version 1.0
4. */
5. public abstract class Duck {
7.     public Duck(){
9.     }
11.     public abstract void display();
13.     public void quack(){
14.         System.out.println("鸭子嘎嘎叫");
15.     }
17.     public void swim(){
18.         System.out.println("鸭子会游泳");
19.     }
21.     public void fly(){
22.         System.out.println("鸭子会飞翔");
23.     }
25. }
26. /**
27. * @author 长名06
28. * @version 1.0
29. */
30. public class ToyDuck extends Duck{
31.     @Override
32.     public void display() {
33.         System.out.println("这是玩具鸭");
34.     }
36.     @Override
37.     public void swim() {
38.         System.out.println("玩具鸭不能游泳");
39.     }
41.     @Override
42.     public void fly() {
43.         System.out.println("玩具鸭不能飞");
44.     }
46.     @Override
47.     public void quack() {
48.         System.out.println("玩具鸭不能叫");
49.     }
50. }
51. /**
52. * @author 长名06
53. * @version 1.0
54. */
55. public class WildDuck extends Duck{
56.     @Override
57.     public void display() {
58.         System.out.println("这是野鸭");
59.     }
60. }
61. /**
62. * @author 长名06
63. * @version 1.0
64. */
65. public class BeJingDuck extends Duck{
66.     @Override
67.     public void display() {
68.         System.out.println("这是北京鸭");
69.     }
71.     //覆盖父类的fly方法
72.     @Override
73.     public void fly() {
74.         System.out.println("北京鸭不能飞翔");
75.     }
76. }

复制代码

传统实现问题分析

• 1.其它鸭子，都继承了Duck类，所以fly让所有子类都会飞了，这是不正确的。
  
• 2.问题1其实是继承的问题，对类的局部改动，尤其超类的局部改动，会影响其他部分。有溢出效应。
  
• 3.为了改进1问题，我们可以覆盖fly方法，来解决
  
• 4.如果我们有一个玩具鸭子ToyDuck，这样就需要ToyDuck去覆盖Duck的所有实现方法 => 解决思路 策略模式(Strategy Pattern)
  

基本介绍

• 1.策略模式(Strategy Pattern)中，定义算法簇，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的用户。
  
• 2.此模式，体现了几种设计原则。第一，将变化的代码从不变的代码分离；第二，针对接口编程而不是具体的类(定义策略模式接口)；第三，多用组合/聚合，少用继承(客户通过组合方式使用策略)。
  

原理类图


说明：从上图可以看到，客户Context，有成员变量strategy或者其他的策略接口，至于需要使用到那个策略，我们可以在构造器中指定。
策略模式实现案例

uml图


代码实现

1. /**
2. * @author 长名06
3. * @version 1.0
4. */
5. public abstract class Duck {
7.     //属性，策略接口
8.     FlyBehavior flyBehavior;
10.     public Duck(){
12.     }
15.     public abstract void display();
17.     public void quack(){
18.         System.out.println("鸭子嘎嘎叫");
19.     }
21.     public void swim(){
22.         System.out.println("鸭子会游泳");
23.     }
25.     public void fly(){
26.         if(flyBehavior != null){
27.             flyBehavior.fly();
28.         }
29.     }
31.     public void setFlyBehavior(FlyBehavior flyBehavior) {
32.         this.flyBehavior = flyBehavior;
33.     }
34. }
35. /**
36. * @author 长名06
37. * @version 1.0
38. */
39. public interface FlyBehavior {
41.     void fly();
43. }
44. /**
45. * @author 长名06
46. * @version 1.0
47. */
48. public class GoodFlyBehavior implements FlyBehavior{
49.     @Override
50.     public void fly() {
51.         System.out.println("飞翔技术很好");
52.     }
53. }
54. /**
55. * @author 长名06
56. * @version 1.0
57. */
58. public class NoFlyBehavior implements FlyBehavior{
59.     @Override
60.     public void fly() {
61.         System.out.println("不会飞");
62.     }
63. }
64. /**
65. * @author 长名06
66. * @version 1.0
67. */
68. public class BadFlyBehavior implements FlyBehavior{
69.     @Override
70.     public void fly() {
71.         System.out.println("飞翔技术还行");
72.     }
73. }
74. /**
75. * @author 长名06
76. * @version 1.0
77. */
78. public class ToyDuck extends Duck {
80.     public ToyDuck(){
81.         flyBehavior = new NoFlyBehavior();
82.     }
84.     @Override
85.     public void display() {
86.         System.out.println("这是玩具鸭");
87.     }
89.     @Override
90.     public void swim() {
91.         System.out.println("玩具鸭不能游泳");
92.     }
94.     @Override
95.     public void quack() {
96.         System.out.println("玩具鸭不能叫");
97.     }
98. }
99. /**
100. * @author 长名06
101. * @version 1.0
102. */
103. public class WildDuck extends Duck {
105.     public WildDuck() {
106.         flyBehavior = new GoodFlyBehavior();
107.     }
109.     @Override
110.     public void display() {
111.         System.out.println("这是野鸭");
112.     }
113. }
114. /**
115. * @author 长名06
116. * @version 1.0
117. */
118. public class BeJingDuck extends Duck {
120.     public BeJingDuck(){
121.         flyBehavior = new BadFlyBehavior();
122.     }
124.     @Override
125.     public void display() {
126.         System.out.println("这是北京鸭");
127.     }
129. }

复制代码

策略模式在JDK-Arrays类的应用

1.JDK的Arrays的Comparator就使用了策略模式。
核心代码

[code]      Integer[] date = {1, 8, 3, 4, 2, 9};        //1.实现降序排列，返回-1放左边，1放右边，0保持不变        //2.comparator就是实现了 Comparator接口的匿名内部类的对象 相当于策略接口的实现类        //3.public int compare(Integer o1, Integer o2) 制定了具体的处理方式        Comparator comparator = new Comparator() {            public int compare(Integer o1, Integer o2) {                if(o1 > o2){                    return 1;                }else{                    return -1;                }            }        };        /**         *  public static  void sort(T[] a, Comparator