设计模式——策略模式

定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

组成：

抽象策略角色：
策略类，通常由一个接口或者抽象类实现。

     具体策略角色：包装了相关的算法和行为。

     环境角色：持有一个策略类的引用，最终给客户端调用。

先看下策略模式的基本代码模版：代码：https://github.com/yyfyyf1994/knowledge/tree/master/src/yyf/designpatterns/strategy

抽象角色：

package yyf.designpatterns.strategy;

public interface Strategy {
public void operate();
}

环境角色：

package yyf.designpatterns.strategy;

/**
* 环境类（Context)
* @author Yu Yufeng
*
*/
public class Context {
private Strategy strategy;

public Context(Strategy strategy) {
this.strategy = strategy;
}

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

public void operate() {
this.strategy.operate();
}
}

两个具体角色：

package yyf.designpatterns.strategy;

public class StrategyA implements Strategy {
@Override
public void operate() {
System.out.println("StrategyA.operate()");
}
}

package yyf.designpatterns.strategy;

public class StrategyB implements Strategy {
@Override
public void operate() {
System.out.println("StrategyB.operate()");
}
}

测试：

package yyf.designpatterns.strategy;

/**
* 策略模式测试
*
* @author Yu Yufeng
*
*/
public class Test {
public static void main(String[] args) {
Context context;
context = new Context(new StrategyA());
context.operate();

context.setStrategy(new StrategyB());
context.operate();
}

}
/**
* 运行结果
*  StrategyA.operate()
*	StrategyB.operate()
*/

简而言之，策略模式就是，当你想用什么策略的时候就传入什么策略去执行。

现在，我们看看策略模式在jdk中的应用。jdk中排序有实现Comparator、Comparable两种方式，其中Comparator比较就使用了策略模式。

 Comparable 是在集合内部定义的方法实现的排序，Comparator 是在集合外部实现的排序。

看其需要实现的方法可知，

Comparable ：比较传进来的值和当前对象比较。

Comparator ：传进来的两个值进行比较，此时这个类是策略模式中的角色是具体对象 ,Comparator 接口是抽象角色。

当我们需要比较两个对象的时候，我们需要实现接口，这个接口就是策略模式中的抽象角色

现在，我们新建了一个Person类来做测试

package yyf.designpatterns.strategy;

import java.util.Comparator;

public class Person implements Comparator<Person> {
public Person() {
}

public Person(int age) {
this.age = age;
}

private int age;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

@Override
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}

}


Test：
package yyf.designpatterns.strategy;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test2 {
public static void main(String[] args) {
List<Person> list =new ArrayList<Person>();
list.add(new Person(1));
list.add(new Person(3));
list.add(new Person(2));

list.sort(new Person());
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).getAge());
}
}
}
/*
* 运行结果：
* 1
* 2
* 3
*/