七、Strategy(策略模式)
描述：定义了一系列的算法，将每一种算法封装起来并可以相互替换使用，策略模式让算法独立于使用它的客户应用而独立变化。
优点：各个部分之间是弱连接
的关系,弱连接的特性使软件具有更强的可扩展性 ，易于维护 ；更重要的是，它大大提高了软件可重用性 。
例子：
举例（TreeSet 、TreeMap就是很好的例子 ）
public class Test {
/*客户端*/
public static void main(String[] args) {
//面向接口
Strategy addStrategy = new AddStrategy();
Strategy subtractStrategy = new SubtractStrategy();
Environment envi
= new Environment(addStrategy);
System.out.println(envi.calculate(5,
2));
//策略的互换
envi.setStrategy(subtractStrategy);
System.out.println(envi.calculate(5, 2));
}
}
/*
*
抽象策略角色
* */
interface Strategy{
public int calculate(int a,int
b);
}
/*
* 具体策略角色，实现加法
* */
class AddStrategy implements Strategy{
@Override
public int calculate(int a, int b) {
return
a+b;
}
}
/*
* 具体策略角色，实现减法
* */
class SubtractStrategy implements
Strategy{
@Override
public int calculate(int a, int b) {
return
a-b;
}
}
/*
* 环境角色
* */
class Environment{
private Strategy strategy;
public void setStrategy(Strategy strategy) {
this.strategy =
strategy;
}
public Environment(Strategy strategy){
this.strategy =
strategy;
}
public int calculate(int a,int b){
return
strategy.calculate(a, b);
}
}
八、Mediator(中介者)
描述：用一个中介对象来封装一系列关于对象交互行为
优点：避免过度耦合，将一对多的关系简化为一对一的关系
举例：
有两个类A和B，类中各有一个数字，并且要保证类B中的数字永远是类A中数字的100倍。也就是说，当修改类A的数时，将这个数字乘以100赋给类B，而修改类B时，要将数除以100赋给类A。类A类B互相影响，就称为同事类。
abstract
class AbstractColleague {
protected int number;
public int
getNumber() {
return number;
}
public void
setNumber(int number){
this.number = number;
}
//注意这里的参数不再是同事类，而是一个中介者
public abstract void setNumber(int number,
AbstractMediator am);
}
class ColleagueA extends
AbstractColleague{
public void setNumber(int number,
AbstractMediator am) {
this.number = number;
am.AaffectB();
}
}
class ColleagueB extends
AbstractColleague{
@Override
public void setNumber(int
number, AbstractMediator am) {
this.number = number;
am.BaffectA();
}
}
abstract class AbstractMediator {
protected AbstractColleague A;
protected AbstractColleague B;
public AbstractMediator(AbstractColleague a, AbstractColleague b) {
A = a;
B = b;
}
public abstract
void AaffectB();
public abstract void BaffectA();
}
class Mediator extends AbstractMediator {
public
Mediator(AbstractColleague a, AbstractColleague b) {
super(a, b);
}
//处理A对B的影响
public void AaffectB() {
int
number = A.getNumber();
B.setNumber(number*100);
}
//处理B对A的影响
public void BaffectA() {
int number =
B.getNumber();
A.setNumber(number/100);
}
}
public class Client {
public static void main(String[] args){
AbstractColleague collA = new ColleagueA();
AbstractColleague collB = new ColleagueB();
AbstractMediator am
= new Mediator(collA, collB);
System.out.println("==========通过设置A影响B==========");
collA.setNumber(1000, am);
System.out.println("collA的number值为："+collA.getNumber());
System.out.println("collB的number值为A的100倍："+collB.getNumber());
System.out.println("==========通过设置B影响A==========");
collB.setNumber(1000, am);
System.out.println("collB的number值为："+collB.getNumber());
System.out.println("collA的number值为B的0.01倍："+collA.getNumber());
}
}
九、Interpreter(解释器)
描述：定义语言的文法
,并且建立一个解释器来解释该语言中的句子
优点：是一个简单语法分析工具，它最显著的优点就是扩展性，修改语法规则只要修改相应的非终结符表达式就可以了，若扩展语法，则只要增加非终结符类就可以了
例子：
为了帮助大家理解Interpreter模式的基本概念，我们在这里只举一个最简单的例子。
让一个表达式a经过PlusExpression解释器处理后使该表达式+1，经过MinusExpression解释器处理后使该表达式-1。
public
class Client {
public static void main(String []args) {
String
inputExpr = "10";
Context context = new
Context(inputExpr);
List list = new ArrayList();
list.add(new PlusExpression());
list.add(new
PlusExpression());
list.add(new MinusExpression());
list.add(new MinusExpression());
list.add(new MinusExpression());
for (int i=0;i<list.size();i++) {
AbstractExpression
expression = (AbstractExpression)list.get(i);
expression.interpret(context);
}
System.out.println(context.getOutput());
}
}
/**
* Context
*
*/
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;
}
}
/**
* Expression & subclass
*
*/
abstract class
AbstractExpression {
public abstract void interpret(Context
context);
}
class PlusExpression extends AbstractExpression {
public void
interpret(Context context) {
System.out.println("PlusExpression
++");
String input = context.getInput();
int parsedResult
= Integer.parseInt(input);
parsedResult ++;
context.setInput(String.valueOf(parsedResult));
context.setOutput(parsedResult);
}
}
class MinusExpression extends AbstractExpression {
public void
interpret(Context context) {
System.out.println("PlusExpression
--");
String input = context.getInput();
int parsedResult =
Integer.parseInt(input);
parsedResult
--;
context.setInput(String.valueOf(parsedResult));
context.setOutput(parsedResult);
}
}
十、Visitor(访问者)
描述：作用于某个对象群中各个对象的操作.
它可以使你在不改变这些对象本身的情况下,定义作用于这些对象的新操作
优点：给原来类层次增加新操作,不必修改整个类层次,只需实现一个具体访问者
例子：
被访问者抽象类Node.java
abstract public class Node
{
public
abstract void accept(Visitor visitor);
/** @link dependency */
/*# Visitor lnkVisitorA; */
}
被访问者实现类NodeA
.java
public class NodeA extends Node
{
public void
accept(Visitor visitor)
{
visitor.visit(this);
}
public String operationA()
{
return "NodeA is
visited";
}
}
被访问者实现类NodeB .java
public class NodeB
extends Node
{
public void accept(Visitor visitor)
{
visitor.visit(this);
}
public String
operationB()
{
return "NodeB is visited";
}
}
访问者类Visitor.java
public class Visitor
{
public void
visit(NodeA nodeA)
{
System.out.println(
nodeA.operationA() );
}
public void visit(NodeB nodeB)
{
System.out.println( nodeB.operationB() );
}
}
增加与迭代被访问者类ObjectStructure.java
public class ObjectStructure
{
private Vector nodes;
/**
* @link aggregation
*/
private Node node;
public ObjectStructure()
{
nodes = new Vector();
}
public void
action(Visitor visitor)
{
for(Enumeration e =
nodes.elements();
e.hasMoreElements();)
{
node = (Node) e.nextElement();
node.accept(visitor);
}
}
public void add(Node node)
{
nodes.addElement(node);
}
}
客户端类Client.java
public class Client
{
private static
ObjectStructure aObjects;
private static Visitor visitor;
static public void main(String[] args)
{
aObjects = new
ObjectStructure();
aObjects.add(new NodeA());
aObjects.add(new NodeB());
visitor = new Visitor();
aObjects.action(visitor);
}
}