策略模式

策略模式

　　　　定义了算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

UML类图

案例: (来自Head First）要创建一直鸭子，该鸭子有4中行为，分别是外观，叫声，飞行，游泳。

　　其中会游泳是所有的鸭子共有的行为，而飞行和叫声不同类型的鸭子各不同。

采用策略设计模式进行设计:

　飞行行为设计:

 1 package strategy;
 2 
 3 /**
 4  * 飞行接口
 5  */
 6 public interface FlyBehavior {
 7     void fly();
 8 }
 9 
10 package strategy;
11 
12 /**
13  * 不会飞
14  */
15 public class FlyNoWay implements FlyBehavior {
16     @Override
17     public void fly() {
18         System.out.println("不会飞");
19     }
20 }
21 
22 package strategy;
23 
24 /**
25  * 用翅膀飞
26  */
27 public class FlyWithWings implements FlyBehavior {
28     @Override
29     public void fly() {
30         System.out.println("用翅膀飞行");
31     }
32 }

叫声行为设计:

 1 package strategy;
 2 
 3 /**
 4  * 叫声接口
 5  */
 6 public interface QuackBehavior {
 7     void quack();
 8 }
 9 
10 package strategy;
11 
12 /**
13  * 呱呱叫类
14  */
15 public class Quack implements QuackBehavior {
16 
17     @Override
18     public void quack() {
19         System.out.println("呱呱叫");
20     }
21 }
22 
23 package strategy;
24 
25 /**
26  * 不会叫类
27  */
28 public class MuteQuack implements QuackBehavior {
29     @Override
30     public void quack() {
31         System.out.println("不会叫");
32     }
33 }
34 
35 package strategy;
36 
37 /**
38  * 吱吱叫类
39  */
40 public class Squeak implements QuackBehavior {
41     @Override
42     public void quack() {
43         System.out.println("吱吱叫");
44     }
45 }

鸭子类:

 1 package strategy;
 2 
 3 /**
 4  * 鸭子的抽象类
 5  */
 6 public abstract class Duck {
 7 
 8     private FlyBehavior flyBehavior;
 9     private QuackBehavior quackBehavior;
10 
11     public Duck() {
12         flyBehavior = new FlyNoWay();
13         quackBehavior = new Quack();
14     }
15 
16     public Duck(FlyBehavior flyBehavior, QuackBehavior quackBehavior) {
17         this.flyBehavior = flyBehavior;
18         this.quackBehavior = quackBehavior;
19     }
20 
21     public void perform() {
22         display();
23         swim();
24         performFly();
25         performQuack();
26     }
27 
28     public abstract void display();
29 
30     public void swim(){
31         System.out.println("会游泳");
32     }
33 
34     public void performFly(){
35         flyBehavior.fly();
36     }
37 
38     public void performQuack(){
39         quackBehavior.quack();
40     }
41 
42     public FlyBehavior getFlyBehavior() {
43         return flyBehavior;
44     }
45 
46     public void setFlyBehavior(FlyBehavior flyBehavior) {
47         this.flyBehavior = flyBehavior;
48     }
49 
50     public QuackBehavior getQuackBehavior() {
51         return quackBehavior;
52     }
53 
54     public void setQuackBehavior(QuackBehavior quackBehavior) {
55         this.quackBehavior = quackBehavior;
56     }
57 }
58 
59 package strategy;
60 
61 /**
62  * 红头鸭类
63  */
64 public class RedHeadDuck extends Duck {
65 
66     public RedHeadDuck(FlyBehavior flyBehavior, QuackBehavior quackBehavior) {
67         super(flyBehavior, quackBehavior);
68     }
69 
70     @Override
71     public void display() {
72         System.out.println("红头鸭");
73     }
74 }
75 
76 package strategy;
77 
78 /**
79  * 绿头鸭类
80  */
81 public class MallardDuck extends Duck {
82     @Override
83     public void display() {
84         System.out.println("绿头鸭");
85     }
86 }

Client调用:

 1 package strategy;
 2 
 3 /**
 4  * 该案例使用了策略模式和模板方法模式
 5  * 策略模式: 用在鸭子的FlyBehavior和QuackBehavior上的各种行为
 6  * 模板方法模式:用在Duck类中的perform()方法，该方法设定了即将执行的步骤，
 7  * 其中部分步骤需要子类具体实现
 8  *
 9  *   策略模式: 定义了算法族，分别封装起来，让他们之间可以互相替换，
10  * 此模式让算法的变化独立于使用算法的客户。
11  */
12 public class Client {
13 
14     public static void main(String[] args) {
15         FlyBehavior flyBehavior = new FlyNoWay();
16         Quack quack = new Quack();
17         Duck duck = new RedHeadDuck(flyBehavior, quack);
18         duck.perform();
19     }
20 }