浅谈（chain of responsibility）责任链模式
private int number;
public Trouble( int number){
this.number=number;
}
public int getNumber() {
return number;
}
public String toString(){
return "问题编号：["+number+"]";
}
}
Support 类：（抽象类，使用了模板方法）
package zyr.dp.cor;
public abstract class Support {
protected abstract boolean resolve(Trouble trouble);
String name;
Support next;
public Support(String name){
this.name=name;
}
public String toString() {
return "对象：<"+name+">";
}
public Support setAndReturnNext(Support next){
this.next=next;
return next;
}
public final void support(Trouble trouble){
if(resolve(trouble)){
done(trouble);
}else if(next!=null){
next.support(trouble);
}else{
fail(trouble);
}
}
protected void fail(Trouble trouble) {
System.out.println(this+"解决问题失败，"+trouble);
}
protected void done(Trouble trouble) {
System.out.println(this+"已经解决问题，"+trouble);
}
}
NoSupport 类：
package zyr.dp.cor;
public class NoSupport extends Support {
public NoSupport(String name) {
super(name);
}
protected boolean resolve(Trouble trouble) {
return false;
}
}
OddSupport 类：
package zyr.dp.cor;
public class OddSupport extends Support {
public OddSupport(String name) {
super(name);
}
protected boolean resolve(Trouble trouble) {
return (trouble.getNumber()%2) == 1 ? true : false;
}
}
SpecialSupport 类：
package zyr.dp.cor;
public class SpecialSupport extends Support {
public int specialNumber;
public SpecialSupport(String name,int specialNumber) {
super(name);
this.specialNumber= specialNumber;
}
protected boolean resolve(Trouble trouble) {
return trouble.getNumber()==specialNumber ? true : false;
}
}
LimitSupport 类：
package zyr.dp.cor;
public class LimitSupport extends Support {
private int limit;
public LimitSupport(String name,int limit) {
super(name);
this.limit=limit;
}
protected boolean resolve(Trouble trouble) {
return trouble.getNumber()<=limit? true : false;
}
}
Main 类：
package zyr.dp.cor;
public class Main {
public static void main(String[] args) {
Support limitSupportLess = new LimitSupport("有限支持小",5);
Support limitSupportMore = new LimitSupport("有限支持大",15);
Support oddSupport = new OddSupport("奇数支持");
Support specialSupport = new SpecialSupport("特定支持",36);
Support noSupport = new NoSupport("没有支持");
limitSupportLess.setAndReturnNext(limitSupportMore).setAndReturnNext(oddSupport).setAndReturnNext(specialSupport).setAndReturnNext(noSupport);
System.out.println("===<有限支持小>尝试解决问题===");
for(int i=0;i<40;i++){
limitSupportLess.support(new Trouble(i));
}
System.out.println("===<特定支持>尝试解决问题===");
for(int i=0;i<40;i++){
specialSupport.support(new Trouble(i));
}
}
}
运行结果：
===<有限支持小>尝试解决问题===
对象：<有限支持小>已经解决问题，问题编号：[0]
对象：<有限支持小>已经解决问题，问题编号：[1]
对象：<有限支持小>已经解决问题，问题编号：[2]
对象：<有限支持小>已经解决问题，问题编号：[3]
对象：<有限支持小>已经解决问题，问题编号：[4]
对象：<有限支持小>已经解决问题，问题编号：[5]
对象：<有限支持大>已经解决问题，问题编号：[6]
对象：<有限支持大>已经解决问题，问题编号：[7]
对象：<有限支持大>已经解决问题，问题编号：[8]
对象：<有限支持大>已经解决问题，问题编号：[9]
对象：<有限支持大>已经解决问题，问题编号：[10]
对象：<有限支持大>已经解决问题，问题编号：[11]
对象：<有限支持大>已经解决问题，问题编号：[12]
对象：<有限支持大>已经解决问题，问题编号：[13]
对象：<有限支持大>已经解决问题，问题编号：[14]
对象：<有限支持大>已经解决问题，问题编号：[15]
对象：<没有支持>解决问题失败，问题编号：[16]
对象：<奇数支持>已经解决问题，问题编号：[17]
对象：<没有支持>解决问题失败，问题编号：[18]
对象：<奇数支持>已经解决问题，问题编号：[19]
对象：<没有支持>解决问题失败，问题编号：[20]
对象：<奇数支持>已经解决问题，问题编号：[21]
评论