策略模式是对算法的包装,是把使用算法的责任和算法本身分割开来,委派给不同的对象管理。策略模式通常把一个系列的算法包装到一系列的策略类里面,作为一个抽象策略类的子类。
下面用比较器的实现来解释一下策略模式:
涉及到三个角色:
● 环境(Client)角色:持有一个Strategy的引用。
● 抽象策略(ComparatorStrategy)角色:这是一个抽象角色,通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
● 具体策略(Strategy)角色:包装了相关的算法或行为。
具体的比较方法Sorter:
public class Sorter<T> {
public void sort(T[] arr, Comparator<T> comparator) {
for(int i=0; i<arr.length - 1; i++) {
int minPos = i;
for(int j=i+1; j<arr.length; j++) {
minPos = comparator.compare(arr[j],arr[minPos])==-1 ? j : minPos;
}
swap(arr, i, minPos);
}
}
void swap(T[] arr, int i, int j) {
T temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
比较器的抽象策略接口:
public interface Comparator<T> {
int compare(T o1, T o2);
}
具体的策略实现:
public class CatHightComparator implements Comparator<Cat> {
//用猫的身高去比较
@Override
public int compare(Cat o1, Cat o2) {
if(o1.weight < o2.weight) return -1;
else if (o1.weight > o2.weight) return 1;
else return 0;
}
}
public class CatWeightComparator implements Comparator<Cat> {
//用猫的体重去比较
@Override
public int compare(Cat o1, Cat o2) {
if(o1.weight < o2.weight) return -1;
else if (o1.weight > o2.weight) return 1;
else return 0;
}
}
public class DogComparator implements Comparator<Dog> {
//用狗的食物来比较
@Override
public int compare(Dog o1, Dog o2) {
if(o1.food < o2.food) return -1;
else if (o1.food > o2.food) return 1;
else return 0;
}
}
测试:
public static void main(String[] args) {
Cat[] a = {new Cat(3, 3), new Cat(5, 5), new Cat(1, 1)};
//Dog[] a = {new Dog(3), new Dog(5), new Dog(1)};
Sorter<Cat> sorter = new Sorter<>();
//使用猫的体重的比较策略
sorter.sort(a, new CatWeightComparator());
System.out.println(Arrays.toString(a));
}