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