java设计模式系列6-----解释器模式,中介者模式,职责链模式

1.解释器模式

Interpreter模式也叫解释器模式,是行为模式之一,它是一种特殊的设计模式,它建立一个解释器,对于特定的计算机程序设计语言,用来解释预先定义的文法.简单地说,Interpereter模式是一种简单地语法解释器构架.
解释器模式应用场景

• 当有一个语言需要解释执行,并且你可将该语言中的句子表示为一个抽象语法树时,可使用解释器模式.而当存在以下情况时该模式效果最好:
• 该文法简单对于复杂的文法,文法的类层次变得庞大而无法管理.此时语法分析程序生成器这样的工具是更好的选择.它们无需构建抽象语法树即可解释表达式,这样可以节省空间而且还可能节省空间.
• 效率不是一个关键问题,最高效的解释器通常不是通过直接解释语法分析树实现的,而是首先将他们转换成另一种形式.例如,正则表达式通常被转换成状态机.但即使在这种情况下,转换器仍可用解释器模式实现,该模式仍是有用的.
  解释器模式的结构
  
  解释器模式的角色和职责
  Context 解释器上下文环境类。用来存储解释器的上下文环境，比如需要解释的文法等。
  AbstractExpression 解释器抽象类。
  ConcreteExpression 解释器具体实现类。

/*
 * 抽象解释器
 */
public abstract class Expression {
	
	public abstract void interpret(Context context);
	
}

public class MinusExpression extends Expression {

	public void interpret(Context context) {
		System.out.println("自动递减");
		String input = context.getInput();
		int inInput = Integer.parseInt(input);
//		inInput--;
		--inInput;
		context.setInput(String.valueOf(inInput));
		context.setOutput(inInput);
	}

}

public class PlusExpression extends Expression {

	public void interpret(Context context) {
		//提示信息
		System.out.println("自动递增");
		//获得上下文环境
		String input = context.getInput();
		//进行类型转换
		int intInput = Integer.parseInt(input);
		//进行递增
//		intInput++;
		++intInput;
		//对上下文环境重新进行赋值
		context.setInput(String.valueOf(intInput));
		context.setOutput(intInput);
	}

}
/*
 * 上下文环境类，用来保存文法
 */
public class Context {
	
	private String input;
	private int output;
	
	public Context(String input) {
		this.input = input;
	}
	
	public String getInput() {
		return input;
	}
	public void setInput(String input) {
		this.input = input;
	}
	public int getOutput() {
		return output;
	}
	public void setOutput(int output) {
		this.output = output;
	}
}
	import java.util.ArrayList;
import java.util.List;

/*
 * client
 */
public class MainClass {
	public static void main(String[] args) {
		String number = "20";
		Context / = new Context(number);
		
//		Expression expression1 = new MinusExpression();
//		expression1.interpret(context);
//		System.out.println(context.getOutput());
//		
//		Expression expression2 = new PlusExpression();
//		expression2.interpret(context);
//		System.out.println(context.getOutput());
//		
//		Expression expression3 = new PlusExpression();
//		expression3.interpret(context);
//		System.out.println(context.getOutput());
//		
//		Expression expression4 = new PlusExpression();
//		expression4.interpret(context);
//		System.out.println(context.getOutput());
		
		List<Expression> list = new ArrayList<Expression>();
		list.add(new PlusExpression());
		list.add(new PlusExpression());
		list.add(new MinusExpression());
		list.add(new MinusExpression());
		list.add(new MinusExpression());
		list.add(new MinusExpression());
		
		for(Expression ex : list) {
			ex.interpret(context);
			System.out.println(context.getOutput());
		}
	}
}

2.中介者模式

Mediator模式也叫中介者模式，是由GoF提出的23种软件设计模式的一种。Mediator模式是行为模式之一，在Mediator模式中，类之间的交互行为被统一放在Mediator的对象中，对象通过Mediator对象同其他对象交互，Mediator对象起着控制器的作用。
中介者模式的结构:

中介者模式的角色和职责
mediator: 中介者类的抽象父类。
concreteMediator: 具体的中介者类。
colleague: 关联类的抽象父类。
concreteColleague:具体的关联类。

package com.ibeifeng.ex2;

public abstract class Person {
	private String name;
	private int condition;
	private Mediator mediator;

	
	public Person(String name, int condition, Mediator mediator) {
		super();
		this.name = name;
		this.condition = condition;
		this.mediator = mediator;
	}
	
	public Mediator getMediator() {
		return mediator;
	}

	public void setMediator(Mediator mediator) {
		this.mediator = mediator;
	}

	


	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getCondition() {
		return condition;
	}
	
	public void setCondition(int condition) {
		this.condition = condition;
	}
	
	public abstract void getPartner(Person person);
	
}
package com.ibeifeng.ex2;

public class Man extends Person {

	public Man(String name, int condition,Mediator mediator) {
		super(name, condition, mediator);
	}

	public void getPartner(Person person) {
		this.getMediator().setMan(this);
		this.getMediator().getPartner(person);
	}
}
package com.ibeifeng.ex2;

public class Woman extends Person {

	public Woman(String name, int condition,Mediator mediator) {
		super(name, condition, mediator);
	}

	public void getPartner(Person person) {
		this.getMediator().setWoman(this);
		this.getMediator().getPartner(person);
	}
	
}
package com.ibeifeng.ex2;

public class Mediator {
	private Man man;
	private Woman woman;
	
	public void setMan(Man man) {
		this.man = man;
	}
	public void setWoman(Woman woman) {
		this.woman = woman;
	}
	
	public void getPartner(Person person) {
		//将搭档设置上
		if(person instanceof Man) {
			this.setMan((Man)person);
		} else {
			this.setWoman((Woman)person);
		}
		//判断条件
		if(man == null || woman == null) {
			System.out.println("汗，我不是同性恋!");
		} else {
			
			if(man.getCondition() == woman.getCondition()) {
				System.out.println(man.getName() + "和" + woman.getName() + "绝配");
			} else {
				System.out.println(man.getName() + "和" + woman.getName() + "不相配");
			}
		}
	}
	
}
package com.ibeifeng.ex2;

public class MainClass {
	public static void main(String[] args) {
		Mediator mediator = new Mediator();
		Person zhangsan = new Man("张三",7,mediator);
		Person lisi = new Man("李四",7,mediator);
		Person xiaofang = new Woman("小芳",7,mediator);
		
		zhangsan.getPartner(lisi);
		
		xiaofang.getPartner(lisi);
	}
}

中介者模式的优点:
1，将系统按功能分割成更小的对象，符合类的最小设计原则
2，对关联对象的集中控制
3，减小类的耦合程度，明确类之间的相互关系：当类之间的关系过于复杂时，其中 任 何一个类的修改都会影响到其他类，不符合类的设计的开闭原则 ，而Mediator模式将原来相互依存的多对多的类之间的关系简化为Mediator控制类与其他关联类的一对多的关系，当其中一个类修改时，可以对其他关联类不产生影响（即使有修改，也集中在Mediator控制类）。
4，有利于提高类的重用性

3.职责链模式

Chain of Responsibility（CoR）模式也叫职责链模式或者职责连锁模式，是行为模式之一，该模式构造一系列分别担当不同的职责的类的对象来共同完成一个任务，这些类的对象之间像链条一样紧密相连，所以被称作职责链模式。
职责链模式的应用场景:
例1：比如客户Client要完成一个任务，这个任务包括a,b,c,d四个部分。首先客户Client把任务交给A，A完成a部分之后，把任务交给B，B完成b部分，…，直到D完成d部分。例2：比如政府部分的某项工作，县政府先完成自己能处理的部分，不能处理的部分交给省政府，省政府再完成自己职责范围内的部分，不能处理的部分交给中央政府，中央政府最后完成该项工作。例3：软件窗口的消息传播。例4：SERVLET容器的过滤器（Filter）框架实现。
职责链模式的基本条件:
要实现Chain of Responsibility模式，需要满足该模式的基本条件：
1，对象链的组织。需要将某任务的所有职责执行对象以链的形式加以组织。
2，消息或请求的传递。将消息或请求沿着对象链传递，以让处于对象链中的对象得到处理机会。3，处于对象链中的对象的职责分配。不同的对象完成不同的职责。
4，任务的完成。处于对象链的末尾的对象结束任务并停止消息或请求的继续传递。
职责链模式的结构:

职责链模式的角色和职责:
Handler 处理类的抽象父类。
concreteHandler 具体的处理类。

package com.ibeifeng.ex2;

public abstract class CarHandler {
	protected CarHandler carHandler;
	
	public CarHandler setNextHandler(CarHandler carHandler) {
		this.carHandler = carHandler;
		return this.carHandler;
	}
	
	public abstract void HandlerCar(); 
}
package com.ibeifeng.ex2;

public class CarHeadHandler extends CarHandler{

	public void HandlerCar() {
		System.out.println("组装车头");
		if(this.carHandler != null) {
			this.carHandler.HandlerCar();
		}
	}

}
package com.ibeifeng.ex2;

public class CarBodyHandler extends CarHandler {

	public void HandlerCar() {
		System.out.println("组装车身");
		if(this.carHandler != null) {
			this.carHandler.HandlerCar();
		}
	}

}
package com.ibeifeng.ex2;

public class CarTailHandler extends CarHandler{

	public void HandlerCar() {
		System.out.println("组装车尾");
		if(this.carHandler != null) {
			this.carHandler.HandlerCar();
		}
	}

}
package com.ibeifeng.ex2;

public class MainClass {
	public static void main(String[] args) {
		CarHandler headH = new CarHeadHandler();
		CarHandler bodyH = new CarBodyHandler();
		CarHandler tailH = new CarTailHandler();

		//组装顺序预先设定好,顺序是车头-->车身-->车尾
		headH.setNextHandler(bodyH);
		bodyH.setNextHandler(tailH);
		
		//调用职责链的链头来完成操作
		headH.HandlerCar();
		
		System.out.println("---------------");
		
		//顺序改变，希望是车身-->车头--车尾
		bodyH.setNextHandler(headH);
		headH.setNextHandler(tailH);
		bodyH.HandlerCar();
		
		//简便操作
		bodyH.setNextHandler(headH).setNextHandler(tailH);
		bodyH.HandlerCar();
		
		
	}
}

职责链模式的优缺点:
优点：
1。责任的分担。每个类只需要处理自己该处理的工作（不该处理的传递给下一个对象完成），明确各类的责任范围，符合类的最小封装原则。
2。可以根据需要自由组合工作流程。如工作流程发生变化，可以通过重新分配对象链便可适应新的工作流程。
3。类与类之间可以以松耦合的形式加以组织。
缺点：
因为处理时以链的形式在对象间传递消息，根据实现方式不同，有可能会影响处理的速度。