Android开发之设计模式-策略模式

在策略模式（Strategy Pattern）

一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。

何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决：将这些算法封装成一个一个的类，任意地替换。

关键代码：实现同一个接口。

应用实例： 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。 3、JAVA AWT 中的 LayoutManager。

优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。

缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。

使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

实例：

刘备要到江东娶老婆了，走之前诸葛亮给赵云（伴郎）三个锦囊妙计，说是按天机拆开解决棘手问题， 嘿，还别说，真是解决了大问题，搞到最后是周瑜陪了夫人又折兵呀，那咱们先看看这个场景是什么样子 的。 先说这个场景中的要素：三个妙计，一个锦囊，一个赵云，妙计是小亮同志给的，妙计是放置在锦囊 里，俗称就是锦囊妙计嘛，那赵云就是一个干活的人，从锦囊中取出妙计，执行，然后获胜，用 JAVA 程序 怎么表现这个呢？我们先看类图：

 

1、定义策略接口

/**
 * 这是诸葛亮老人家给赵云的三个锦囊妙计的接口
 * */
public interface Istrategy {
    //每个锦囊妙计都是一个可执行的算法
    void operate();
}

2、三个实现类，有三个妙计嘛：

BackDoor.java

/**找乔国老帮忙，使孙权不能杀刘备*/
public class BackDoor implements Istrategy{
    @Override
    public void operate() {
        System.out.print("找乔国老帮忙，让吴国太给孙权施加压力");
    }
}

GiveGreenLight.java

/**求吴国太开个绿灯*/
public class GiveGreenLight implements Istrategy{
    @Override
    public void operate() {
        System.out.print("求吴国太开个绿灯，放行");
    }
}

BlockEnemy.java

/**孙夫人断后，挡住追兵**/
public class BlockEnemy implements Istrategy{
    @Override
    public void operate() {
        System.out.print("孙夫人断后，挡住追兵");
    }
}

3、三个妙计是有了，那需要有个地方放这些妙计呀，放锦囊呀：

/**计谋有了，那还要有锦囊*/
public class Context {
    //构造函数，你要使用那个妙计
    private Istrategy istrategy;
    public Context(Istrategy istrategy){
        this.istrategy = istrategy;
    }

    //使用计谋了，看我出招了
    public void operate(){
        this.istrategy.operate();
    }
}

4、然后就是赵云雄赳赳的揣着三个锦囊，拉着已步入老年行列的、还想着娶纯情少女的、色迷迷的刘老 爷子去入赘了，嗨，还别说，小亮的三个妙计还真是不错，瞅瞅：

​
public class ZhaoYun {
    /**
     * 赵云出场了，他根据诸葛亮给他的交代，依次拆开妙计
     */
    public static void main(String [] args){
        Context context;

        //刚刚到吴国的时候拆第一个
        System.out.print("------------刚刚到吴国的时候拆第一个-----------");
        context = new Context(new BackDoor());//拿到妙计
        context.operate();//拆开执行
        System.out.print("\n\n\n\n\n\n\n\n\n");

        //刘备乐不思蜀了，拆第二个了
        System.out.print("------------刘备乐不思蜀了，拆第二个了-----------");
        context = new Context(new GiveGreenLight());
        context.operate();//执行了第二个锦囊了
        System.out.println("\n\n\n\n\n\n\n\n");

        //孙权的小兵追了，咋办？拆第三个
        System.out.println("-----------孙权的小兵追了，咋办？拆第三个-------");
        context = new Context(new BlockEnemy());
        context.operate();//孙夫人退兵
        /**
         *问题来了：赵云实际不知道是那个策略呀，他只知道拆第一个锦囊，
         *而不知道是BackDoor这个妙计，咋办？ 似乎这个策略模式已经把计谋名称写出来了
         *
         * 错！BackDoor、GivenGreenLight、BlockEnemy只是一个代码，你写成first、second、
        third，没人会说你错!
         *
         * 策略模式的好处就是：体现了高内聚低耦合的特性呀，缺点嘛，1、策略类会增多。 2、所有策略类都需要对外暴露。
         */
    }
}

​

5、执行程序，输出结果

就这三招，搞的周郎是“陪了夫人又折兵”呀！这就是策略模式，高内聚低耦合的特点也表现出来了， 还有一个就是扩展性，也就是 OCP 原则，策略类可以继续增加下去，只要修改 Context.java 就可以了。

实例2：

假设我们要出去旅游，而去旅游出行的方式有很多，有步行，有坐火车，有坐飞机等等。而如果不使用任何模式，我们的代码可能就是这样子的。

public class TravelStrategy {
	enum Strategy{
		WALK,PLANE,SUBWAY
	}
	private Strategy strategy;
	public TravelStrategy(Strategy strategy){
		this.strategy=strategy;
	}
	
	public void travel(){
		if(strategy==Strategy.WALK){
			print("walk");
		}else if(strategy==Strategy.PLANE){
			print("plane");
		}else if(strategy==Strategy.SUBWAY){
			print("subway");
		}
	}
	
	public void print(String str){
		System.out.println("出行旅游的方式为："+str);
	}
	
	public static void main(String[] args) {
		TravelStrategy walk=new TravelStrategy(Strategy.WALK);
		walk.travel();
		
		TravelStrategy plane=new TravelStrategy(Strategy.PLANE);
		plane.travel();
		
		TravelStrategy subway=new TravelStrategy(Strategy.SUBWAY);
		subway.travel();
	}
}

这样做有一个致命的缺点，一旦出行的方式要增加，我们就不得不增加新的else if语句，而这违反了面向对象的原则之一，对修改封闭。而这时候，策略模式则可以完美的解决这一切。

1、需要定义一个策略接口。

public interface Strategy {
    void travel();
}

2、然后根据不同的出行方式实行对应的接口

public class WalkStrategy implements Strategy{

	@Override
	public void travel() {
		System.out.println("walk");
	}

}

 

public class PlaneStrategy implements Strategy{

	@Override
	public void travel() {
		System.out.println("plane");
	}

}

 

public class SubwayStrategy implements Strategy{

	@Override
	public void travel() {
		System.out.println("subway");
	}

}

3、 此外还需要一个包装策略的类，并调用策略接口中的方法

public class TravelContext {
	Strategy strategy;

	public Strategy getStrategy() {
		return strategy;
	}

	public void setStrategy(Strategy strategy) {
		this.strategy = strategy;
	}

	public void travel() {
		if (strategy != null) {
			strategy.travel();
		}
	}
}

 4、测试一下代码

public class Main {
	public static void main(String[] args) {
		TravelContext travelContext=new TravelContext();
		travelContext.setStrategy(new PlaneStrategy());
		travelContext.travel();
		travelContext.setStrategy(new WalkStrategy());
		travelContext.travel();
		travelContext.setStrategy(new SubwayStrategy());
		travelContext.travel();
	}
}

5、执行程序，输出结果

 

可以看到，应用了策略模式后，如果我们想增加新的出行方式，完全不必要修改现有的类，我们只需要实现策略接口即可，这就是面向对象中的对扩展开放准则。假设现在我们增加了一种自行车出行的方式。只需新增一个类即可。

public class BikeStrategy implements Strategy{

	@Override
	public void travel() {
		System.out.println("bike");
	}

}

之后设置策略即可

public class Main {
	public static void main(String[] args) {
		TravelContext travelContext=new TravelContext();
		travelContext.setStrategy(new BikeStrategy());
		travelContext.travel();
	}
}

策略模式详解链接：

https://wenku.baidu.com/view/57f37f4fc850ad02de804152.html?st=1

下篇观察者模式，待续...