<Java设计模式> 策略模式-
1.策略模式概念
策略模式(Strategy Pattern)体现了两个非常基本的面向对象设计原则。
1> 封装变化概念 ；
2> 编程中使用接口，而不是对接口的实现，即面向接口编程。
2.定义：
1> 定义一组算法，将每个算法都封装起来，并且使他们之间可以作为组建互相替换；
2> 策略模式使这些算法在客户端调用它们的时候能够互不影响的变化。
3.意义：
1> 策略模式使开发人员能够开发出由许多可替换的部分组成的软件，并且各部分之间是
松耦合的关系；
2> 若连接的特性是软件具有更强的可扩展性，易于维护；更重要的是，他大大提高了软件
的可重用性。
4.策略模式的组成：
1> 抽象策略角色：策略类，通常由一个接口或者抽象类实现；
2> 具体策略角色：包装了相关的算法和行为，由实现接口或抽象类的类完成；
3> 环境角色：持有一个策略类的引用，最后给客户端调用。
5.策略模式的实现：
1> 策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立类中，
从而使得它们可以相互替换；
2> 策略模式使得算法可以在不影响客户端的情况下发生变化。使用策略模式可以把
行为和环境分割开来；
3> 环境类负责维持和查询行为类，各种算法则在具体策略中提供。由于算法和环境
相独立，算法的修改都不会影响环境和客户端。
6.编写步骤：
1> 对策略对象定义一个公共接口（抽象策略角色）；
2> 编写各种策略类，该类实现了上面的公共接口（具体策略角色）；
3> 在使用策略对象的类中保存一个策略对象的引用（环境角色）；
4> 在使用策略对象的类中，实现对策略对象的set和get方法（注入）或者使用构造方法完成赋值
例1：
Strategy.java(抽象策略角色,接口实现)
策略模式(Strategy Pattern)体现了两个非常基本的面向对象设计原则。
1> 封装变化概念 ；
2> 编程中使用接口，而不是对接口的实现，即面向接口编程。
2.定义：
1> 定义一组算法，将每个算法都封装起来，并且使他们之间可以作为组建互相替换；
2> 策略模式使这些算法在客户端调用它们的时候能够互不影响的变化。
3.意义：
1> 策略模式使开发人员能够开发出由许多可替换的部分组成的软件，并且各部分之间是
松耦合的关系；
2> 若连接的特性是软件具有更强的可扩展性，易于维护；更重要的是，他大大提高了软件
的可重用性。
4.策略模式的组成：
1> 抽象策略角色：策略类，通常由一个接口或者抽象类实现；
2> 具体策略角色：包装了相关的算法和行为，由实现接口或抽象类的类完成；
3> 环境角色：持有一个策略类的引用，最后给客户端调用。
5.策略模式的实现：
1> 策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立类中，
从而使得它们可以相互替换；
2> 策略模式使得算法可以在不影响客户端的情况下发生变化。使用策略模式可以把
行为和环境分割开来；
3> 环境类负责维持和查询行为类，各种算法则在具体策略中提供。由于算法和环境
相独立，算法的修改都不会影响环境和客户端。
6.编写步骤：
1> 对策略对象定义一个公共接口（抽象策略角色）；
2> 编写各种策略类，该类实现了上面的公共接口（具体策略角色）；
3> 在使用策略对象的类中保存一个策略对象的引用（环境角色）；
4> 在使用策略对象的类中，实现对策略对象的set和get方法（注入）或者使用构造方法完成赋值
例1：
Strategy.java(抽象策略角色,接口实现)
package cn.edu.bupt.strategy;
public interface Strategy {
int calculate(int a, int b);
}
(具体策略角色,分为两个实现类,如下)
AddStrategy.java
package cn.edu.bupt.strategy;
public class AddStrategy implements Strategy {
@Override
public int calculate(int a, int b) {
return a + b;
}
}
SubstractStrategy.java
package cn.edu.bupt.strategy;
public class SubstractStrategy implements Strategy {
@Override
public int calculate(int a, int b) {
return a - b;
}
}
(环境角色,持有接口的引用但是没有接口的具体实现类,即面向接口编程,拥有setters 和 getters)
Environment.java
package cn.edu.bupt.strategy;
public class Environment {
private Strategy stra; //Strategy类型,面向接口编程
public Environment(){
super();
}
public Environment(Strategy stra) {
super();
this.stra = stra;
}
public Strategy getStra() {
return this.stra;
}
public void setStra(Strategy stra) {
this.stra = stra;
}
public int calculate(int a, int b) {
return this.stra.calculate(a, b);
}
}
(客户端,持有环境类,但是需要通过使用setters 和 getters向环境类中传入具体的算法,即策略具体实现类)
Client.java
package cn.edu.bupt.strategy;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a = 3;
int b = 4;
//实例化环境决策,完成相关的运算
Environment env = new Environment();
//传入减法策略,执行减法运算
env.setStra(new SubstractStrategy());
System.out.println(env.calculate(a, b));
//传入加法策略,执行加法运算
env.setStra(new AddStrategy());
System.out.println(env.calculate(a, b));
}
}
策略模式的缺点：
1> 客户端必须知道所有的实现算法的具体策略类，并自行解决使用哪个策略类；
2> 会造成很多的抽象类
例2：
Person.java(领域模型)
package cn.edu.bupt.personsort2;
public class Person {
private int id;
private String name;
private int age;
public Person(int id, String name, int age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
//setters and getters
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;
}
}
PersonSort.java(抽象策略类)
package cn.edu.bupt.personsort2;
import java.util.List;
public interface PersonSort {
void sort(List<Person> persons);
}
(具体策略算法类包含以下三种)
PersonSortById.java
package cn.edu.bupt.personsort2;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class PersonSortById implements Comparator<Person>, PersonSort {
@Override
public void sort(List<Person> persons) {
// TODO Auto-generated method stub
Collections.sort(persons, this);
}
@Override
public int compare(Person p1, Person p2) {
// TODO Auto-generated method stub
int tag = 0;
if(p1.getId() < p2.getId()) {
tag = -1;
}
else if(p1.getId() == p2.getId()) {
tag = 0;
}
else {
tag = 1;
}
return tag;
}
}
PersonSortByName.java
package cn.edu.bupt.personsort2;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class PersonSortByName implements PersonSort, Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
// TODO Auto-generated method stub
int tag = 0;
if(p1.getName().compareTo(p2.getName()) < 0) {
tag = -1;
}
else if(p1.getName().compareTo(p2.getName()) > 0) {
tag = 1;
}
else {
if(p1.getId() < p2.getId()) {
tag = -1;
}
else if(p1.getId() > p2.getId()) {
tag = 1;
}
else {
tag = 0;
}
}
return tag;
}
@Override
public void sort(List<Person> persons) {
// TODO Auto-generated method stub
Collections.sort(persons, this);
}
}
PersonSortByAge.java
package cn.edu.bupt.personsort2;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class PersonSortByAge implements PersonSort, Comparator<Person> {
@Override
public void sort(List<Person> persons) {
// TODO Auto-generated method stub
Collections.sort(persons, this);
}
@Override
public int compare(Person p1, Person p2) {
// TODO Auto-generated method stub
int tag = 0;
if(p1.getAge() < p2.getAge()) {
tag = -1;
}
else if(p1.getAge() > p2.getAge()) {
tag = 1;
}
else {
if(p1.getId() < p2.getId()) {
tag = 1;
}
else if(p1.getId() == p2.getId()) {
tag = 0;
}
else {
tag = -1;
}
}
return tag;
}
}
Environment.java(环境类)
package cn.edu.bupt.personsort2;
import java.util.List;
public class Environment {
private PersonSort psort = null;
private List<Person> persons = null;
public Environment(PersonSort psort, List<Person> persons) {
super();
this.psort = psort;
this.persons = persons;
}
//getters and setters
public PersonSort getPsort() {
return psort;
}
public void setPsort(PersonSort psort) {
this.psort = psort;
}
public List<Person> getPersons() {
return persons;
}
public void setPersons(List<Person> persons) {
this.persons = persons;
}
public void sort() {
this.psort.sort(this.persons);
}
}
Client.java
package cn.edu.bupt.personsort2;
import java.util.ArrayList;
import java.util.List;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Person p1 = new Person(1, "zhangsan", 14);
Person p2 = new Person(2, "lisi", 14);
Person p3 = new Person(3, "wangwu", 15);
Person p4 = new Person(4, "wangwu", 15);
List<Person> persons = new ArrayList<Person>();
persons.add(p1);
persons.add(p2);
persons.add(p3);
persons.add(p4);
//构造环境类,并传入相应的算法类实例,按照年龄排序
Environment env = new Environment(new PersonSortByAge(), persons);
env.sort();
//修改算法类实例传入,按照名字排序
env.setPsort(new PersonSortByName());
env.sort();
//同上,按照ID排序
env.setPsort(new PersonSortById());
env.sort();
for(Person p: persons) {
System.out.println(p.getId() + ":" + p.getName() + ":" + p.getAge());
}
}
}
浙公网安备 33010602011771号