java设计模式学习笔记之策略模式

java设计模式学习笔记之策略模式

尊重原创，转载请注明出处，原文地址： http://blog.csdn.net/qq137722697

这是一个使用策略模式和构建模式设计的网络请求框架，去看看吧《[倾力之作]android轻量级网络请求框架MyHttputils2.1.6》

思想就是利用向上转型

场景

今天上班要用什么方式？公交？地铁？自行车？( 用java实现 )

public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        System.out.print("你要怎么上班？(1、公交；2、地铁；3、自行车)：");
        int way = scn.nextInt();
        switch (way) {
            case 1:
                System.out.println("公交上班了 （怎么上？这里有1000行代码省略了）");
                break;
            case 2:
                System.out.println("地铁上班了 （怎么上？这里有1000行代码省略了）");
                break;
            case 3:
                System.out.println("自行车上班了 （怎么上？这里有1000行代码省略了）");
                break;
        }
    }

分析

你可能看到“怎么上？这里有1000行代码省略了”的注释，如果真要写这么多代码，你就全部写在一个类中，是不是太没有水平了，真实项目可就不好维护了！接下来来看看策略模式的魅力吧！

我们来分析分析，对于上班这件事，我们可以选择公交、地铁、自行车，而最终的结果就是到达公司，说白了就是只有过程（方式）的策略不一样，让我们来抽取一下，有这么一个类（出行策略类），这个类的功能就是上班，但是怎么上班是没有体现的，怎么上班就交个它的子类来完成。

实现

出行的策略抽成一个接口

/**
 * 出行的策略
 * Created by HDL on 2016/11/30.
 */
public interface GoWorkStrategy {
    void goWork();
}

自行车出行类 实现于（继承至）GoWorkStrategy出行的策略

public class BicycleStrategy implements GoWorkStrategy {
    @Override
    public void goWork() {
        System.out.println("自行车出行");
    }
}

地铁出行类 实现于（继承至）GoWorkStrategy出行的策略

public class MetroStrategy implements GoWorkStrategy {
    @Override
    public void goWork() {
        System.out.println("地铁出行");
    }
}

公交车出行类 实现于（继承至）GoWorkStrategy出行的策略

public class BusStrategy implements GoWorkStrategy {
    @Override
    public void goWork() {
        System.out.println("公交出行");
    }
}

还需要一个专门用于提供出行方式的类（ProvideWorkWay），这个类持有出行策略的引用，startGo即开始出行

public class ProvideWorkWay {
    private GoWorkStrategy strategy;
    public ProvideWorkWay(GoWorkStrategy strategy) {
        this.strategy = strategy;
    }
    public void startGo() {
        strategy.goWork();
    }
}

怎么出行？来看看怎么用吧

  public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        System.out.print("你要怎么上班？(1、公交；2、地铁；3、自行车)：");
        int way = scn.nextInt();
        ProvideWorkWay provideWorkWay = null;
        switch (way) {
            case 1:
                provideWorkWay = new ProvideWorkWay(new BusStrategy());
                break;
            case 2:
                provideWorkWay = new ProvideWorkWay(new MetroStrategy());
                break;
            case 3:
                provideWorkWay = new ProvideWorkWay(new BicycleStrategy());
                break;
        }
        provideWorkWay.startGo();
    }

这就是一个简单的策略模式，即它定义了算法家族，分别封装起来，让它们之间可以互相替换，次模式让算法的变化，不会影响都使用算法的客户。

细心的人可能会发现，测试类（客户端、使用者）中还是有switch，耦合性还是比较高，怎么办呢？

看过上一篇《java设计模式学习笔记之计算器中的简单工厂模式》的你肯定会想到用简单工厂模式封装一下就好了！

对 ! 这里将策略模式与简单工厂模式相结合

只需要修改这个专门用于提供出行方式的类即可：

//出行方式提供类
public class ProvideWorkWay {
    private GoWorkStrategy strategy;
    public ProvideWorkWay(int way) {//根据不同的出行方式来实例化对象
        switch (way) {
            case 1:
                strategy = new BusStrategy();
                break;
            case 2:
                strategy = new MetroStrategy();
                break;
            case 3:
                strategy = new BicycleStrategy();
                break;
        }
    }
    public void startGo() {
        strategy.goWork();
    }
}

//出行方式提供类

public class ProvideWorkWay {
    private GoWorkStrategy strategy;
    public ProvideWorkWay(int way) {//根据不同的出行方式来实例化对象
        switch (way) {
            case 1:
                strategy = new BusStrategy();
                break;
            case 2:
                strategy = new MetroStrategy();
                break;
            case 3:
                strategy = new BicycleStrategy();
                break;
        }
    }
    public void startGo() {
        strategy.goWork();
    }
}

这样逻辑处理与界面是不是就分开了，代码结构清晰的同时也降低了耦合性，便于维护和进行单元测试

对比一下单独的策略模式和简单工厂模式+策略模式的结合的特点；

单独的策略模式：

ProvideWorkWay provideWorkWay = new ProvideWorkWay(new BusStrategy());
               provideWorkWay.startGo();

结合的方式：

ProvideWorkWay provideWorkWay = new ProvideWorkWay(way);
               provideWorkWay.startGo();

结合的方式只暴露了一个ProvideWorkWay类给使用者，而策略模式需要将ProvideWorkWay和BusStrategy一起暴露出来，明显单独的策略模式耦合性更高。

策略模式

策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同， 它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法者之间的耦合度。（大白话讲就是同一算法不同实现）

尊重原创，转载请注明出处，原文地址： http://blog.csdn.net/qq137722697