3策略模式.docx
- 文档编号:30478588
- 上传时间:2023-08-15
- 格式:DOCX
- 页数:14
- 大小:17.12KB
3策略模式.docx
《3策略模式.docx》由会员分享,可在线阅读,更多相关《3策略模式.docx(14页珍藏版)》请在冰豆网上搜索。
3策略模式
★策略模式中体现了两个非常基本的面向对象设计的原则:
--封装变化的概念
--编程中使用接口,而不是对接口的实现
★面向接口的编程,实现类之间的弱耦合
★策略模式的定义
--定义一组算法,将每个算法都封装起来,并且使它们之间可以互换。
--策略模式使这些算法在客户端调用它们的时候能够互不影响变化。
★策略模式的组成
--抽象策略角色:
策略类,通常由一个接口或者抽象类实现
--具体角色:
包装了相关的算法和行为。
--环境角色:
持有一个策略类的引用,最终给客户端调用。
★策略模式的实现:
--策略模式的用意是针对一组算法,将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换。
--策略模式使得算法可以在不影响到客户端的情况下发生变化。
使用策略模式可以把行为和环境分割开来。
--环境类负责维持和查询行为类,各种算法则在具体策略中提供。
由于算法和环境独立开来,算法的修改都不会影响环境和客户端。
★策略模式的缺点
1.客户端必须知道所有的策略类,并自行决定使用哪一个策略类
2.造成很多的策略类。
★解决方案—采用工厂方法。
抽象策略角色
publicinterfaceAbstractStrategy
{
publicintcalculate(inta,intb);
}
具体角色
publicclassAddStrategyimplementsAbstractStrategy
{
publicintcalculate(inta,intb)
{
returna+b;
}
}
publicclassDevideStrategyimplementsAbstractStrategy
{
publicintcalculate(inta,intb)
{
returna/b;
}
}
publicclassMutipleStrategyimplementsAbstractStrategy
{
publicintcalculate(inta,intb)
{
returna*b;
}
}
publicclassSubtractStrategyimplementsAbstractStrategy
{
publicintcalculate(inta,intb)
{
returna-b;
}
}
环境角色
publicclassEnviorment
{
privateAbstractStrategystrategy;
publicEnviorment(AbstractStrategystrategy)
{
this.strategy=strategy;
}
publicAbstractStrategygetStrategy()
{
returnstrategy;
}
publicvoidsetStrategy(AbstractStrategystrategy)
{
this.strategy=strategy;
}
publicintcalculate(inta,intb)
{
returnstrategy.calculate(a,b);
}
}
★应用举例:
有这样一个类
publicclassPerson
{
privateintid;
privateStringname;
privateintage;
}
使用一个集合来保存它的多个对象,要求对这个集合进行排序,排序规则如下:
可以按Id,name, age进行升序或降序排列,当name或age相同时,要求按id的升序进行排序。
★具体实现过程
Person类
publicclassPerson
{
privateintid;
privateStringname;
privateintage;
publicPerson(intid,Stringname,intage)
{
this.id=id;
this.name=name;
this.age=age;
}
publicintgetId()
{
returnid;
}
publicvoidsetId(intid)
{
this.id=id;
}
publicStringgetName()
{
returnname;
}
publicvoidsetName(Stringname)
{
this.name=name;
}
publicintgetAge()
{
returnage;
}
publicvoidsetAge(intage)
{
this.age=age;
}
publicinthashCode()
{
finalintprime=31;
intresult=1;
result=prime*result+age;
result=prime*result+id;
result=prime*result+((name==null)?
0:
name.hashCode());
returnresult;
}
publicbooleanequals(Objectobj)
{
if(this==obj)
returntrue;
if(obj==null)
returnfalse;
if(getClass()!
=obj.getClass())
returnfalse;
Personother=(Person)obj;
if(age!
=other.age)
returnfalse;
if(id!
=other.id)
returnfalse;
if(name==null)
{
if(other.name!
=null)
returnfalse;
}
elseif(!
name.equals(other.name))
returnfalse;
returntrue;
}
publicStringtoString()
{
return"Person[id="+id+",name="+name+",age="+age+"]";
}
}
抽象策略类
publicinterfaceAbstractSortStrategy
{
publicvoidascSort();
publicvoiddescSort();
}
ID排序类
publicclassIdSortStrategyimplementsAbstractSortStrategy
{
privateListlist;
publicIdSortStrategy(Listlist)
{
this.list=list;
}
publicvoidascSort()
{
Collections.sort(list,newIdComparator());
}
publicvoiddescSort()
{
Comparatorr=Collections.reverseOrder(newIdComparator());
Collections.sort(list,r);
}
}
classIdComparatorimplementsComparator
{
publicintcompare(Objectarg0,Objectarg1)
{
Personp1=(Person)arg0;
Personp2=(Person)arg1;
returnp1.getId()-p2.getId();
}
}
Name排序类
publicclassNameSortStrategyimplementsAbstractSortStrategy
{
privateListlist;
publicNameSortStrategy(Listlist)
{
this.list=list;
}
publicvoidascSort()
{
Collections.sort(list,newNameComparator());
}
publicvoiddescSort()
{
Comparatorr=Collections.reverseOrder(newNameComparator());
Collections.sort(list,r);
}
}
classNameComparatorimplementsComparator
{
publicintcompare(Objectarg0,Objectarg1)
{
Personp1=(Person)arg0;
Personp2=(Person)arg1;
if(p1.getName()==p2.getName())
{
returnp1.getId()-p2.getId();
}
returnp1.getName().compareTo(p2.getName());
}
}
Age排序类
publicclassAgeSortStrategyimplementsAbstractSortStrategy
{
privateListlist;
publicAgeSortStrategy(Listlist)
{
this.list=list;
}
publicvoidascSort()
{
Collections.sort(list,newAgeComparator());
}
publicvoiddescSort()
{
Comparatorr=Collections.reverseOrder(newAgeComparator());
Collections.sort(list,r);
}
}
classAgeComparatorimplementsComparator
{
publicintcompare(Objectarg0,Objectarg1)
{
Personp1=(Person)arg0;
Personp2=(Person)arg1;
if(p1.getAge()==p2.getAge())
{
returnp1.getId()-p2.getId();
}
returnp1.getAge()-p2.getAge();
}
}
管理排序规则类
publicclassPersonSort
{
privateAbstractSortStrategystrategy;
publicPersonSort(AbstractSortStrategystrategy)
{
this.strategy=strategy;
}
publicAbstractSortStrategygetStrategy()
{
returnstrategy;
}
publicvoidsetStrategy(AbstractSortStrategystrategy)
{
this.strategy=strategy;
}
publicvoidascSort()
{
strategy.ascSort();
}
publicvoiddescSort()
{
strategy.descSort();
}
}
测试结果
publicclassPersonTest
{
publicstaticvoidmain(String[]args)
{
Listlist=newArrayList();
Personp1=newPerson(8,"Bob",23);
Personp2=newPerson(7,"Jack",25);
Personp3=newPerson(1,"Mike",30);
Personp4=newPerson(6,"Judy",21);
Personp5=newPerson(4,"Lisa",35);
Personp6=newPerson(5,"Linda",36);
Personp7=newPerson(2,"Joho",22);
Personp8=newPerson(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排序测试");
PersonSortsort=newPersonSort(newIdSortStrategy(list));
TestSort(list,sort);
//----------------姓名排序测试----------------------------------------
System.out.println("姓名排序测试");
sort=newPersonSort(newNameSortStrategy(list));
TestSort(list,sort);
//----------------年龄排序测试----------------------------------------
System.out.println("年龄排序测试");
sort=newPersonSort(newAgeSortStrategy(list));
TestSort(list,sort);
}
privatestaticvoidTestSort(Listlist,PersonSortsort)
{
sort.ascSort();
System.out.println("升序排列");
output(list);
sort.descSort();
System.out.println("降序排列");
output(list);
}
privatestaticvoidoutput(Listlist)
{
for(inti=0;i { Personp=(Person)list.get(i); System.out.println(p); } System.out.println("---------------"); } }
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 策略 模式