标签：
为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。
|
//接口 package ChainOfResponsibility;
public interface Operator { public void method(); }
|
|
//抽象类 package ChainOfResponsibility;
public abstract class AbstractHandler { private Handler handler = null;
public Handler getHandler(){ return this.handler; }
public void setHandler(Handler handler){ this.handler = handler; } }
|
|
//实现类 package ChainOfResponsibility;
public class Handler extends AbstractHandler implements Operator{ private String name;
public Handler(String name){ this.name = name; }
@Override public void method() { // TODO Auto-generated method stub System.out.println(this.name); if(this.getHandler() != null){ this.getHandler().method(); } } }
|
|
//测试类 package ChainOfResponsibility;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Handler h1 = new Handler("h1"); Handler h2 = new Handler("h2"); Handler h3 = new Handler("h3"); h1.setHandler(h2); h2.setHandler(h3);
h1.method(); }
} |
1. 有多个对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
2. 在不明确指定接收者的情况下，向多个对象中的一个提交请求。
3. 可以处理一个请求的对象集合应被动态指定。
讲一个请求封装成一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可取消的操作。
|
//接口 package Command;
public interface Command { public void exe(); }
|
|
//接口实现类 package Command;
public class MyCommand implements Command { private operator o;
public MyCommand(operator o){ this.o = o; }
@Override public void exe() { // TODO Auto-generated method stub o.operate(); }
}
|
|
//命令实行类 package Command;
public class operator{ public void operate(){ System.out.println("operator..."); } }
|
|
//命令唤起类 package Command;
public class Invoker { private Command c;
public Invoker(Command c){ this.c = c; }
public void Commanding(){ c.exe(); } }
|
|
//测试类 package Command;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub operator o = new operator(); Command c = new MyCommand(o); Invoker i = new Invoker(c); i.Commanding(); }
}
|
给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
|
//接口 package Interpreter;
public interface Interpretable { public int interpreter(Entity entity); }
|
|
//语言 package Interpreter;
public class Entity { private int num1; private int num2;
public Entity(int num1, int num2){ this.num1 = num1; this.num2 = num2; }
public int getNum1(){ return this.num1; }
public int getNum2(){ return this.num2; }
public void setNum1(int num1){ this.num1 = num1; } public void setNum2(int num2){ this.num2 = num2; } }
|
|
//解释1 package Interpreter;
public class Plus implements Interpretable {
@Override public int interpreter(Entity entity) { // TODO Auto-generated method stub return entity.getNum1() + entity.getNum2(); }
}
//解释2 package Interpreter;
public class Minus implements Interpretable {
@Override public int interpreter(Entity entity) { // TODO Auto-generated method stub return entity.getNum1() - entity.getNum2(); }
}
|
|
//测试类 package Interpreter;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub int result = new Minus().interpreter(new Entity(3,5)); System.out.println(result); }
}
|
当有一个语言需要解释执行，并且可以将该语言中的句子表示为一个抽象的语法树时，可以使用解释器模式。
提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
|
//集合接口 package Iterator;
public interface CollectionInterface { public Iterator iterator(); public Object get(int i); public int size(); }
|
|
//迭代器接口 package Iterator;
public interface IteratorInterface { public Object prev(); public Object next(); public boolean hasNext(); }
|
|
//集合实现 package Iterator;
public class Collection implements CollectionInterface { private String str[] = {"A", "B", "C", "D", "E"};
@Override public Iterator iterator() { // TODO Auto-generated method stub return new Iterator(this); }
@Override public Object get(int i) { // TODO Auto-generated method stub return str[i]; }
@Override public int size() { // TODO Auto-generated method stub return str.length; }
}
|
|
//迭代器实现 package Iterator;
public class Iterator implements IteratorInterface { private Collection collection; private int pos = -1; public Iterator(Collection collection){ this.collection = collection; } @Override public Object prev() { // TODO Auto-generated method stub if(pos > 0){ pos--; return this.collection.get(pos); } return null; }
@Override public Object next() { // TODO Auto-generated method stub if(pos < this.collection.size()-1){ pos++; return this.collection.get(pos); } return null; }
@Override public boolean hasNext() { // TODO Auto-generated method stub if(pos < this.collection.size()-1){ return true; } return false; }
}
|
|
//测试 package Iterator;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Collection c = new Collection(); Iterator i = new Iterator(c);
while(i.hasNext()){ System.out.println(i.next()); } }
}
|
1. 访问一个聚合对象的内容而无需暴露它的内部表示。
2. 支持对聚合对象的多种遍历。
3. 为遍历不同的聚合结构提供一个统一的接口（即支持多态迭代）。
用一个中介对象来封装一系列的对象的交互。中介者使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
|
//中介者接口 package Mediator;
public interface MediatorInterface { public void createMediator(); public void workAll(); }
|
|
//中介者实现 package Mediator;
public class Mediator implements MediatorInterface { private User user1; private User user2;
public Mediator(){ }
@Override public void createMediator() { // TODO Auto-generated method stub this.user1 = new User1(this); this.user2 = new User2(this); }
@Override public void workAll() { // TODO Auto-generated method stub user1.operate(); user2.operate();
}
}
|
|
//抽象类（待解耦合的对象） package Mediator;
public abstract class User { private Mediator mediator; public User(Mediator mediator){ this.mediator = mediator; }
public Mediator getMediator(){ return this.mediator; }
public abstract void operate();
}
|
|
//实现类1（待解耦合的对象） package Mediator;
public class User1 extends User {
public User1(Mediator mediator){ super(mediator); } @Override public void operate() { // TODO Auto-generated method stub System.out.println("user1..."); }
}
//实现类2（待解耦合的对象） package Mediator;
public class User2 extends User {
public User2(Mediator mediator){ super(mediator); } @Override public void operate() { // TODO Auto-generated method stub System.out.println("user2..."); }
}
|
|
//测试类 package Mediator;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Mediator mediator = new Mediator(); mediator.createMediator(); mediator.workAll(); }
}
|
1. 一组对象以定义好良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱而且难以理解。
2. 一个对象引用其他多个对象并且直接与这些对象通信，导致难以复用该对象。
3. 想定制一个分部在多个类中的行为，而又不想生成太多子类。
在不破坏封装性的前提下，捕获一个对象内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。
|
//原始类 package Memento;
public class Original { private String value;
public Original(){ }
public String getValue(){ return this.value; }
public void setValue(String value){ this.value = value; }
public Memento createMemento(){ Memento memento = new Memento(this.value); return memento; }
public void recovery(Memento memento){ this.value = memento.getValue(); } }
|
|
//备份类 package Memento;
public class Memento { private String value;
public Memento(String value){ this.value = value; }
public String getValue(){ return this.value; }
public void setValue(String value){ this.value = value; } }
|
|
//备份储存 package Memento;
public class Storage { Memento memento; public Storage(Memento memento){ this.memento = memento; }
public Memento getMemento(){ return this.memento; }
public void setMemento(Memento memento){ this.memento = memento; } }
|
|
//测试类 package Memento;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Original original = new Original(); original.setValue("original..."); Storage storage = new Storage(original.createMemento()); System.out.println(original.getValue()); original.setValue("new..."); System.out.println(original.getValue()); original.recovery(storage.getMemento()); System.out.println(original.getValue()); }
}
|
1. 必须保存一个对象在某个时刻的（部分）状态，这样以后需要它才能恢复到先前的状态。
2. 如果一个用接口来让其他对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。
定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动刷新
|
//观测类接口 package Observer;
public interface ObserverInterface { public void update(); }
|
|
//观测实现类1 package Observer;
public class Observer1 implements ObserverInterface {
@Override public void update() { // TODO Auto-generated method stub System.out.println("1..."); }
}
//观测实现类2 package Observer;
public class Observer2 implements ObserverInterface {
@Override public void update() { // TODO Auto-generated method stub System.out.println("2..."); }
}
|
|
//抽象主题类 package Observer;
import java.util.Vector;
public abstract class Subject { private Vector<ObserverInterface> vector = new Vector<ObserverInterface>();
public Subject(){ }
public void addObserver(ObserverInterface observer){ this.vector.add(observer); }
public void deleteObserver(ObserverInterface observer){ this.vector.remove(observer); }
public void notifyObservers(){ for(ObserverInterface oi : vector){ oi.update(); } }
public abstract void operate(); } |
|
//实现主题类 package Observer;
public class MySubject extends Subject {
@Override public void operate() { // TODO Auto-generated method stub System.out.println("updating..."); notifyObservers(); }
}
|
|
//测试类 package Observer;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub MySubject ms = new MySubject(); Observer1 ob1 = new Observer1(); Observer2 ob2 = new Observer2(); ms.addObserver(ob1); ms.addObserver(ob2); ms.operate();
ms.deleteObserver(ob1); ms.operate(); }
}
|
1. 当一个抽象类型有两个方面，其中一个方面依赖于另一方面。将这两者封装在独立的对象中以使它们可以各自独立地改变和复用
2. 当每一个对象的改变需要同时改变其它对象，而不知道具体有多少对象有待改变
3. 当每一个对象必须通知其它对象，而它又不能假定其它对象是谁。
允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的所属类。
|
//状态类 package State;
public class State { private String value;
public String getValue(){ return this.value; } public void setValue(String value){ this.value = value; } public void operate1(){ System.out.println("1..."); } public void operate2(){ System.out.println("2..."); } }
|
|
//状态切换类 package State;
public class Context { private State state;
public Context(State state){ this.state = state; } public State getState(){ return this.state; } public void setState(State state){ this.state = state; } public void method(){ if(state.getValue() == "1"){ state.operate1(); } else if(state.getValue() == "2"){ state.operate2(); } } }
|
|
//测试类 package State;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub State s = new State(); Context c = new Context(s); c.getState().setValue("1"); c.method(); c.getState().setValue("2"); c.method(); }
}
|
1. 一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为
2. 一个操作中含有庞大的分支条件语句，且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举变量表示。通常，有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这使得你可以根据对象自身的情况将对象的状态作为一个对象，这一个对象可以不依赖于其他对象而独立变化。
定义一系列的算法，把它们一个一个封装起来并且使它们可相互替换。本模式使得算法的变化可独立于使用它的用户。
|
//策略接口 package Strategy;
public interface StrategyInterface { public int cal(String exp); }
|
|
//策略抽象类 package Strategy;
public abstract class Strategy { public int[] split(String exp, String opt){ String array[] = exp.split(opt); int arrayInt[] = new int[2]; arrayInt[0] = Integer.parseInt(array[0]); arrayInt[1] = Integer.parseInt(array[1]); return arrayInt; } }
|
|
//策略实现类1 package Strategy;
public class plus extends Strategy implements StrategyInterface {
@Override public int cal(String exp) { // TODO Auto-generated method stub int arrayInt[] = split(exp, "\\+"); return arrayInt[0]+arrayInt[1]; }
}
|
|
//策略实现类2 package Strategy;
public class minus extends Strategy implements StrategyInterface {
@Override public int cal(String exp) { // TODO Auto-generated method stub int arrayInt[] = split(exp, "-"); return arrayInt[0]-arrayInt[1]; }
} |
|
//策略实现类3 package Strategy;
public class multiply extends Strategy implements StrategyInterface {
@Override public int cal(String exp) { // TODO Auto-generated method stub int arrayInt[] = split(exp, "\\*"); return arrayInt[0]*arrayInt[1]; }
}
|
|
//测试类 package Strategy;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub String exp = "2+8"; StrategyInterface strategy = new plus(); int result = strategy.cal(exp); System.out.println(result); }
} |
1. 许多相关类仅仅是行为有意。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。
2. 需要使用一个算法的不同变体。
3. 使用策略模式可以避免暴露复杂的、与算法相关的数据结构。
4. 一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy类中以替代这些条件语句。
定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
|
//模板 package Template;
public abstract class Template { public final int calculate(String exp, String opt){ String[] array = exp.split(opt); return calculate(Integer.parseInt(array[0]),Integer.parseInt(array[1])); }
public abstract int calculate(int num1, int num2); }
|
|
//模板实现1 package Template;
public class plus extends Template {
@Override public int calculate(int num1, int num2) { // TODO Auto-generated method stub return num1+num2; }
}
//模板实现2 package Template;
public class minus extends Template {
@Override public int calculate(int num1, int num2) { // TODO Auto-generated method stub return num1-num2; }
}
|
|
//测试 package Template;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub String exp1 = "1+2"; Template t1 = new plus(); int result1 = t1.calculate(exp1, "\\+"); System.out.println(result1);
String exp2 = "5-3"; Template t2 = new minus(); int result2 = t2.calculate(exp2, "-"); System.out.println(result2); }
} |
1. 一次性实现一个算法的不变的部分，并将可变的行为留给子类实现
2. 各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。首先识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后用一个调用这些新的操作的模板方法来替换这些不同的代码。
3. 控制子类的扩展。
表示一个作用于对象结构中的各元素的操作。它使你可以在不改变个元素的类的前提下定义作用于这些元素的新操作。
|
//subject接口 package Visitor;
public interface SubjectInterface { public void acceptVisit(VisitorInterface visitor); public String getSubject(); }
|
|
//visitor接口 package Visitor;
public interface VisitorInterface { public void visit(SubjectInterface sub); }
|
|
//subject实现 package Visitor;
public class Subject implements SubjectInterface {
@Override public void acceptVisit(VisitorInterface visitor) { // TODO Auto-generated method stub visitor.visit(this); }
@Override public String getSubject() { // TODO Auto-generated method stub return "love"; }
}
|
|
//visitor实现 package Visitor;
public class Visitor implements VisitorInterface {
@Override public void visit(SubjectInterface sub) { // TODO Auto-generated method stub System.out.println(sub.getSubject()); } }
|
|
//测试类 package Visitor;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub VisitorInterface v = new Visitor(); SubjectInterface sub = new Subject(); sub.acceptVisit(v); }
}
|
1. 一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。
2. 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作“污染”这些对象的类。Visitor使得你可以将相关的操作集中起来定义在一个类中。当该对象结构被很多应用程序共享时，用Visitor模式让每一个应用仅包含所需要用到的操作。
3. 定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。改变对象结构类需要重新定义所有访问者的接口。这可能需要很大的代价。如果对象结构经常改变，那么可能还是在这些类中定义这些操作较好。
http://blog.csdn.net/lhy_ycu/article/details/40031567
http://blog.csdn.net/zhangerqing/article/details/8194653
设计模式：可复用面向对象软件的基础
标签：
原文地址：http://www.cnblogs.com/SailorXun/p/4284766.html
