★策略模式中体现了两个非常基本的面向对象设计的原则：
--封装变化的概念
--编程中使用接口，而不是对接口的实现
★面向接口的编程，实现类之间的弱耦合
★策略模式的定义
--定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。
--策略模式使这些算法在客户端调用它们的时候能够互不影响变化。
★策略模式的组成
--抽象策略角色：策略类，通常由一个接口或者抽象类实现
--具体角色：包装了相关的算法和行为。
--环境角色：持有一个策略类的引用，最终给客户端调用。
★策略模式的实现：
--策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。
--策略模式使得算法可以在不影响到客户端的情况下发生变化。使用策略模式可以把行为和环境分割开来。
--环境类负责维持和查询行为类，各种算法则在具体策略中提供。由于算法和环境独立开来，算法的修改都不会影响环境和客户端。
★策略模式的缺点
1.客户端必须知道所有的策略类，并自行决定使用哪一个策略类
2.造成很多的策略类。
★解决方案—采用工厂方法。
抽象策略角色
|
public interface AbstractStrategy { public int calculate(int a , int b); } |
具体角色
|
public class AddStrategy implements AbstractStrategy { public int calculate(int a, int b) { return a + b; } } public class DevideStrategy implements AbstractStrategy { public int calculate(int a, int b) { return a / b ; } } public class MutipleStrategy implements AbstractStrategy { public int calculate(int a, int b) { return a * b; } } public class SubtractStrategy implements AbstractStrategy { public int calculate(int a, int b) { return a - b; } } |
环境角色
|
public class Enviorment { private AbstractStrategy strategy; public Enviorment(AbstractStrategy
strategy) { this.strategy = strategy; } public AbstractStrategy
getStrategy() { return strategy; } public void setStrategy(AbstractStrategy
strategy) { this.strategy = strategy; } public int calculate(int a , int b) { return strategy.calculate(a, b); } } |
★应用举例：
有这样一个类
|
public class Person { private int id; private String name; private int age; } |
使用一个集合来保存它的多个对象，要求对这个集合进行排序，排序规则如下：
可以按Id，name, age进行升序或降序排列，当name 或age相同时，要求按id的升序进行排序。
★具体实现过程
Person类
|
public class Person { private int id; private String name; private int age; public Person(int id , String
name, int age) { this.id = id; this.name = name; this.age = age; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + id; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (age != other.age) return false; if (id != other.id) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } public String toString() { return "Person [id=" + id + ", name=" + name + ", age=" + age + "]"; } } |
抽象策略类
|
public interface AbstractSortStrategy { public void ascSort(); public void descSort(); } |
ID排序类
|
public class IdSortStrategy implements
AbstractSortStrategy { private List list; public IdSortStrategy(List list) { this.list = list; } public void ascSort() { Collections.sort(list , new IdComparator()); } public void descSort() { Comparator r = Collections.reverseOrder(new IdComparator()); Collections.sort(list, r); } } class IdComparator implements Comparator { public int compare(Object arg0, Object arg1) { Person p1 = (Person)arg0; Person p2 = (Person)arg1; return p1.getId()-p2.getId(); } } |
Name排序类
|
public class NameSortStrategy implements
AbstractSortStrategy { private List list; public NameSortStrategy(List list) { this.list = list; } public void ascSort() { Collections.sort(list , new
NameComparator()); } public void descSort() { Comparator r = Collections.reverseOrder(new
NameComparator()); Collections.sort(list, r); } } class NameComparator implements Comparator { public int compare(Object arg0, Object arg1) { Person p1 = (Person)arg0; Person p2 = (Person)arg1; if(p1.getName() == p2.getName()) { return p1.getId() - p2.getId(); } return
p1.getName().compareTo(p2.getName()); } } |
Age排序类
|
public class AgeSortStrategy implements
AbstractSortStrategy { private List list; public AgeSortStrategy(List list) { this.list = list; } public void ascSort() { Collections.sort(list , new
AgeComparator()); } public void descSort() { Comparator r = Collections.reverseOrder(new
AgeComparator()); Collections.sort(list, r); } } class AgeComparator implements Comparator { public int compare(Object arg0, Object arg1) { Person p1 = (Person)arg0; Person p2 = (Person)arg1; if(p1.getAge() == p2.getAge()) { return p1.getId() - p2.getId(); } return p1.getAge()-p2.getAge(); } } |
管理排序规则类
|
public class PersonSort { private AbstractSortStrategy strategy; public
PersonSort(AbstractSortStrategy strategy) { this.strategy = strategy; } public AbstractSortStrategy
getStrategy() { return strategy; } public void
setStrategy(AbstractSortStrategy strategy) { this.strategy = strategy; } public void ascSort() { strategy.ascSort(); } public void descSort() { strategy.descSort(); } } |
测试结果
|
public class PersonTest { public static void main(String[] args) { List list = new ArrayList(); Person p1 = new Person(8 , "Bob", 23); Person p2 = new Person(7 , "Jack", 25); Person p3 = new Person(1 , "Mike", 30); Person p4 = new Person(6 , "Judy", 21); Person p5 = new Person(4 , "Lisa", 35); Person p6 = new Person(5 , "Linda", 36); Person p7 = new Person(2 , "Joho", 22); Person p8 = new Person(3 , "Bob", 25); list.add(p1); list.add(p2); list.add(p3); list.add(p4); list.add(p5); list.add(p6); list.add(p7); list.add(p8); //排序前的状态 System.out.println("排序前的状态"); output(list); //-----------------Id排序测试--------------------------------------- System.out.println("Id排序测试"); PersonSort sort = new PersonSort(new
IdSortStrategy(list)); TestSort(list, sort); //----------------姓名排序测试---------------------------------------- System.out.println("姓名排序测试"); sort = new PersonSort(new NameSortStrategy(list)); TestSort(list, sort); //----------------年龄排序测试---------------------------------------- System.out.println("年龄排序测试"); sort = new PersonSort(new AgeSortStrategy(list)); TestSort(list, sort); } private static void TestSort(List
list,PersonSort sort) { sort.ascSort(); System.out.println("升序排列"); output(list); sort.descSort(); System.out.println("降序排列"); output(list); } private static void output(List list) { for(int i = 0; i<list.size(); i++) { Person p = (Person)list.get(i); System.out.println(p); } System.out.println("---------------"); } } |