Java设计模式之策略模式

1. 设计模式入门

---

设计模式不是代码的具体实现，它是解决某一类问题的通用设计方案。
设计模式的本质目的是：使软件工程在维护性、扩展性、变化性、复杂度方面成0（N）
OO设计是原则，设计模式是具体方法、工具。
例如：
在Java里IO流的类设计，为什么把BufferedReader设计成：

new BufferedReader（new FileReader（“F：\test.java”））;
//而不是设计成：
BufferedReader extends FileReader;
new BufferedReader("F:\test.java");

2. 策略模式原理

---

2.1 模拟鸭子项目

2.1.1 从OO的角度设计这个项目

鸭子具有相同的叫声以及都会游泳，但是每只鸭子的颜色不同，比如说有绿头鸭，红头鸭等。

2.1.2 从OO的角度设计这个项目

• 1.设置鸭子超类

public abstract class SuperDuck {
    //颜色让子类去具体实现
    public abstract void display();
    public void quack(){
        System.out.println("~GaGa~");
    }
    public void swim(){
        System.out.println("~In Swim~");
    }
}

• 2.生成绿头鸭子类

public class GreenDuck extends SuperDuck {
    @Override
    public void display() {
        // TODO Auto-generated method stub
        System.out.println("~show Green Head~");
    }
}

• 3.生成红头鸭子类

public class RedDuck extends SuperDuck {

    @Override
    public void display() {
        // TODO Auto-generated method stub
        System.out.println("~Show Red Head~");
    }
}

使用OO基本满足了项目的需求。

2.2 项目的新需求

2.2.1 应对新的需求，看看这个设计的可扩展性

需求1）添加会飞的鸭子
在OO思维解决这个问题，使用：
在鸭子超类中添加这个方法：

public abstract class SuperDuck {
    //颜色让子类去具体实现
    public abstract void display();
    public void quack(){
        System.out.println("~GaGa~");
    }
    public void swim(){
        System.out.println("~In Swim~");
    }
    public void fly(){
        System.out.println("In Fly");
    }
}

2.3 用OO原则解决需求的不足

问题出现：这个fly（）让所有的鸭子都飞起来了，这是不科学的
继承问题：对类的局部的变动，尤其是超类的局部变动，会影响其他部分。影响会有溢出效应。
使用覆盖解决问题：
在子类中对超类的方法进行覆盖，在超类中，进行改动的话，必须在子类中进行全面的覆盖。（如果已经生成上千个子类？需要对这些子类重新进行初始化，这个方法并不可行）
需求2）添加石头鸭子，就需要对以上所有方法进行覆盖。

public class StoneDuck extends Duck{

}

超类挖的一个坑，每个子类都要填，增加工作量，复杂度O(N^2)

2.4 用策略模式来解决鸭子的项目

目的：使用新的设计模式，应对项目的扩展性，降低复杂度。
1）分析项目变化与不变部分，提取变化部分，抽象成接口+实现；
2）鸭子哪些功能是会根据新需求变化的？叫声、 飞行…
解决方法：接口

public interface  SuperFly();
public interface  SuperQuack();

好处：新增行为简单，行为类更好的复用，组合更方便。 既有继承带来的复用好处，没有挖坑。

2.5 重新设计模拟鸭子项目

2.5.1 dx.com.quack(叫声实现)

• SuperQuack

package dx.com.quack;

public interface SuperQuack {
    public void quack();
}

• Gaquack

package dx.com.quack;

public class Gaquack implements SuperQuack {

    @Override
    public void quack() {
        // TODO Auto-generated method stub
        System.out.println("~Ga~Ga~");
    }

}

• GeQuack

package dx.com.quack;

public class GeQuack implements SuperQuack {

    @Override
    public void quack() {
        // TODO Auto-generated method stub
        System.out.println("~Ge~Ge~");
    }

}

• NoQuack

package dx.com.quack;

import dx.com.stimulate.SuperDuck;

public class NoQuack extends SuperDuck {

    @Override
    public void display() {
        // TODO Auto-generated method stub
        System.out.println("~  ~  ~");
    }

}

2.5.2 dx.com.quack(飞行实现)

• SuperFly

package dx.com.fly;

public interface SuperFly {
    public void fly();
}

• NoFly

package dx.com.fly;

public class NoFly implements SuperFly {

    @Override
    public void fly() {
        // TODO Auto-generated method stub
        System.out.println("NO Fly");
    }

}

• GoodFly

package dx.com.fly;

public class GoodFly implements SuperFly{

    @Override
    public void fly() {
        // TODO Auto-generated method stub
        System.out.println("Good Fly");
    }
}

• BadFly

package dx.com.fly;

public class BadFly implements SuperFly{

    @Override
    public void fly() {
        // TODO Auto-generated method stub
        System.out.println("Bad fly");
    }

}

2.5.3 dx.com.duck

• SuperDuck

package dx.com.duck;

import dx.com.fly.SuperFly;
import dx.com.quack.SuperQuack;

public abstract class SuperDuck {
    public SuperFly superFly;
    public SuperQuack superQuack;

    public SuperDuck() {
    };

    public abstract void display();

    public void fly() {
        superFly.fly();
    }

    public void quack() {
        superQuack.quack();
    }

    public void setFly(SuperFly fly) {
        this.superFly = fly;
    }

    public void setQuack(SuperQuack quack) {
        this.superQuack = quack;
    }
}

• GreenDuck

package dx.com.duck;

import dx.com.fly.GoodFly;
import dx.com.quack.Gaquack;

public class GreenDuck extends SuperDuck {

    public GreenDuck(){
        superFly = new GoodFly();
        superQuack = new Gaquack();
    }

    @Override
    public void display() {
        // TODO Auto-generated method stub
        System.out.println("show green head");
    }

}

• RedDuck

package dx.com.duck;

import dx.com.fly.BadFly;
import dx.com.quack.GeQuack;
import dx.com.quack.SuperQuack;

public class RedDuck extends SuperDuck{

    public RedDuck(){
        superFly = new BadFly();
        superQuack = new GeQuack();
    }
    @Override
    public void display() {
        // TODO Auto-generated method stub
        System.out.println("show red head");
    }
}

2.6 总结策略模式定义

策略模式：分别封装行为借口，实现算法族，超类里放行为接口对象，在子类里具体设定行为对象。原则就是：分离变化备份，封装接口，基于接口编程各种功能。此模式让行为算法的变化独立于算法的使用者。

3. 策略模式注意点

• 1.分析项目中变化部分与不变部分
• 2.多用组合少用继承；用行为类组合，而不是行为的继承。更有弹性
• 3.设计模式有没有相应的库直接使用？有些库或框架本身就用某种设计模式设计的

代码链接：http://download.csdn.net/detail/it_dx/9667812