23种设计模式的代码
package lq.test;import java.io.*;import java.util.*;//*********创建型模式***************//factory method 1//1具体的构造算法，和2构造出的具体产品由子类实现interface Product {}//或者我也提供一个工厂的接口，由这个抽象类来继承它abstract class Factory {abstract public Product fmd();;//我认为这个方方法的存在是，是对FactoryMethod方法的补充//例如可以为生成的对象赋值，计算为生成对象应付何值，前后的日值//且这些都是公用的，生成产品的最主要算法还是在FactoryMethod中，//这个方法只是起辅助作用，这也是一种思维方法，将具体的算法实现在一个方法中//而我不直接调用此方法，而使用另外的一个方法封装它，等到了更灵活的效果，而//子类需实现的内容是FactoryMethod//此方法是一个TemplateMethodpublic Product creat(); {Product pd = null;System.out.println("before operation");;pd = fmd();;System.out.println("end operation");;return pd;}}class Product1 implements Product {}class Factory1 extends Factory {public Product fmd(); {Product pd = new Product1();;return pd;}}//FactroyMethod 2//这种方式简单实用interface Producta {}interface Factorya {Producta create();;}class Producta1 implements Producta {}class Factorya1 implements Factorya {public Producta create(); {Producta pda = null;pda = new Producta1();;return pda;} }//AbstractFactory//AbstractFactory与FactoryMethod的不同在于AbstractFactory创建多个产品//感觉此模式没有什么大用//当然可以还有更多的接口interface Apda {}interface Apdb {}interface Afactory {Apda createA();;Apdb createB();;}class Apda1 implements Apda {}class Apdb1 implements Apdb {}//有几个接口就有几个对应的方法class Afactory1 implements Afactory {public Apda createA(); {Apda apda = null;apda = new Apda1();;return apda;}public Apdb createB(); {Apdb apdb = null;apdb = new Apdb1();;return apdb;}}//Builder//一个产品的生成分为生成部件和组装部件，不同的产品每个部件生成的方式不同//而组装的方式相同，部件的生成抽象成接口方法，而组装的方法使用一个TemplateMethod方法interface Cpda {}class Cpda1 implements Cpda {}interface BuilderI {void buildPart1();;void buildPart2();;void initPd();;Cpda getPd();;}abstract class BuilderA implements BuilderI {Cpda cpda;public Cpda getPd(); {initPd();;//对对象的内容进行设置buildPart1();;buildPart2();;return cpda;}}class Builder extends BuilderA {public void buildPart1(); {System.out.println(cpda);;}public void buildPart2(); {System.out.println(cpda);;}public void initPd(); {cpda = new Cpda1();;}}//一个简单的生成产品的实现//1abstract class Fy {public abstract void med1();; static class Fy1 extends Fy {public void med1(); {}}public static Fy getInstance(); {Fy fy = new Fy1();;return fy;//Fy fy = new Fy1(); {//这种匿名内部类是静态的！！//public void med1(); {//}//};//return fy;}}//2interface Pdd {}class Pdd1 implements Pdd {}abstract class Fya {public static Pdd getPd(); {Pdd pdd = new Pdd1();;return pdd;}}//Prototype 在java中就是clone，又包含深拷贝和浅拷贝class CloneObja {public CloneObja MyClone(); {return new CloneObja();;}}class CloneObjb {public CloneObjb MyClone(); throws Throwable {CloneObjb cobj = null;cobj = (CloneObjb); pcl(this);;return cobj;}//深度拷贝算法private Object pcl(Object obj); throws Throwable {ByteArrayOutputStream bao = new ByteArrayOutputStream(1000);;ObjectOutputStream objo = new ObjectOutputStream(bao);;objo.writeObject(obj);;ByteArrayInputStream bai = new ByteArrayInputStream(bao.toByteArray(););;ObjectInputStream obji = new ObjectInputStream(bai);;Object objr = obji.readObject();;return objr;} }//Singleton//一个类只有一个对象，例如一个线程池，一个cacheclass Singleton1 {public static Singleton1 instance = new Singleton1();;private Singleton1(); {}public static Singleton1 getInstance(); {return instance;}}class Singleton2 {public static Singleton2 instance;private Singleton2(); {}//public static Singleton2 getInstance(); {//if (instance == null); {//instance = new Singleton2();;//}////return instance;//}public static Singleton2 getInstance(); {synchronized(Singleton2.class); {if (instance == null); {instance = new Singleton2();;}}return instance;}}//**********结构型模式**********//Adapter//基本方法有两种，一种是使用引用一种使用继承//将不符合标准的接口转成符合标准的接口，接口的修改主要是参数的增减，//返回值类型,当然还有方法名//感觉这就是封装的另一种表示形式，封装有用方法封装(在方法中调用功能方法);，//用类封装(先传入功能方法所在的类的对象，通过调用此对象的功能方法);//使用引用的形式class Adapteea {public void kk(); {}}interface Targeta {String vv(int i, int k);;}class Adaptera implements Targeta{Adapteea ade;public Adaptera(Adapteea ade); {this.ade = ade;}public String vv(int i, int k); {//具体的业务方法实现在Adaptee中，这个方法//只起到了接口转换的作用//调用此方法是通过引用ade.kk();;return null;}}//使用继承形式的class Adapteeb {public void kk(); {}}interface Targetb {String vv(int i, int k);;}class Adapterb extends Adapteeb implements Targetb {public String vv(int i, int k); {//调用此方法是通过继承kk();;return null;}}//Proxyinterface Subject {void request();;} class realSubject implements Subject {public void request(); {//do the real business}}class Proxy implements Subject {Subject subject;public Proxy(Subject subject); {this.subject = subject;}public void request(); {System.out.println("do something");;subject.request();;System.out.println("do something");;}}//Bridge//感觉就是多态的实现interface Imp {void operation();;}class Cimp1 implements Imp {public void operation(); {System.out.println("1");;}}class Cimp2 implements Imp {public void operation(); {System.out.println("2");;}}class Invoker {Imp imp = new Cimp1();;public void invoke(); {imp.operation();;}}//Compositeinterface Component {void operation();;void add(Component component);;void remove(Component component);;}class Leaf implements Component {public void operation(); {System.out.println("an operation");;}public void add(Component component); {throw new UnsupportedOperationException();;}public void remove(Component component); {throw new UnsupportedOperationException();;}}class Composite implements Component {List components = new ArrayList();;public void operation(); {Component component = null;Iterator it = components.iterator();;while (it.hasNext();); {//不知道此component对象是leaf还是composite，//如果是leaf则直接实现操作，如果是composite则继续递归调用component = (Component); it.next();;component.operation();;}}public void add(Component component); {components.add(component);;}public void remove(Component component); {components.remove(component);;}}//Decorator//对一个类的功能进行扩展时，我可以使用继承，但是不够灵活，所以选用了//另外的一种形式,引用与继承都可活得对对象的一定的使用能力，而使用引用将更灵活//我们要保证是对原功能的追加而不是修改，否则只能重写方法，或使用新的方法//注意concrete的可以直接new出来，//而decorator的则需要用一个另外的decorator对象才能生成对象//使用对象封装，和公用接口//Decorator链上可以有多个元素interface Componenta {void operation();;}class ConcreteComponent implements Componenta {public void operation(); {System.out.println("do something");;}}class Decorator implements Componenta {private Componenta component;public Decorator(Componenta component); {this.component = component;}public void operation(); {//do something beforecomponent.operation();;//do something after}}//Facade//非常实用的一种设计模式，我可以为外部提供感兴趣的接口class Obj1 {public void ope1(); {}public void ope2(); {}}class Obj2 {public void ope1(); {}public void ope2(); {}}class Facade {//我得到了一个简洁清晰的接口public void fdMethod(); {Obj1 obj1 = new Obj1();;Obj2 obj2 = new Obj2();;obj1.ope1();;obj2.ope2();; }}//Flyweight//空//**********行为型模式*************//Chain of Responsibility//与Decorator的实现形式相类似，//Decorator是在原来的方法之上进行添加功能，而//Chain则是判断信号如果不是当前处理的则转交个下一个节点处理//我可以使用if分支来实现相同的效果，但是不够灵活，链上的每个节点是可以替换增加的，相对//比较灵活，我们可以设计接口实现对节点的增删操作，而实现更方便的效果//这个是一个链状的结构，有没有想过使用环状结构interface Handler {void handRequest(int signal);;}class CHandler1 implements Handler {private Handler handler;public CHandler1(Handler handler); {this.handler = handler;}public void handRequest(int signal); {if (signal == 1); {System.out.println("handle signal 1");;}else {handler.handRequest(signal);;}} }class CHandler2 implements Handler {private Handler handler;public CHandler2(Handler handler); {this.handler = handler;}public void handRequest(int signal); {if (signal == 2); {System.out.println("handle signal 2");;}else {handler.handRequest(signal);;}} }class CHandler3 implements Handler {public void handRequest(int signal); {if (signal == 3); {System.out.println("handle signal 3");;}else {throw new Error("can't handle signal");;}} }class ChainClient {public static void main(String[] args); {Handler h3 = new CHandler3();;Handler h2 = new CHandler2(h3);;Handler h1 = new CHandler1(h2);;h1.handRequest(2);;}}//Interpreter//感觉跟Composite很类似，只不过他分文终结符和非终结符//Template Methodabstract class TemplateMethod {abstract void amd1();;abstract void amd2();;//此方法为一个Template Method方法public void tmd(); {amd1();;amd2();;}}//State//标准型//状态和操作不应该耦合在一起class Contexta {private State st;public Contexta(int nst); {changeStfromNum(nst);;}public void changeStfromNum(int nst); {if (nst == 1); {st = new CStatea1();;}else if (nst == 2); {st = new CStatea2();;}throw new Error("bad state");;}void request(); {st.handle(this);;}}interface State {void handle(Contexta context);;}class CStatea1 implements State {public void handle(Contexta context); {System.out.println("state 1");;//也许在一个状态的处理过程中要改变状态，例如打开之后立即关闭这种效果//context.changeStfromNum(2);;}}class CStatea2 implements State {public void handle(Contexta context); {System.out.println("state 2");;}}//工厂型//根据状态不通生成不同的state//class StateFactory {//public static State getStateInstance(int num); {//State st = null;////if (num == 1); {//st = new CStatea1();;//}//else if (num == 2); {//st = new CStatea2();;//}////return st;//}//}//Strategy//跟Bridge相类似，就是一种多态的表示//Visitor//双向引用，使用另外的一个类调用自己的方法,访问自己的数据结构interface Visitor {void visitElement(Elementd element);;}class CVisitor implements Visitor {public void visitElement(Elementd element); {element.operation();;}}interface Elementd {void accept(Visitor visitor);;void operation();;}class CElementd implements Elementd {public void accept(Visitor visitor); {visitor.visitElement(this);;}public void operation(); {//实际的操作在这里}}class Clientd {public static void main(); {Elementd elm = new CElementd();;Visitor vis = new CVisitor();;vis.visitElement(elm);;}}//Iteraotr//使用迭代器对一个类的数据结构进行顺序迭代interface Structure {interface Iteratora {void first();;boolean hasElement();;Object next();;}}class Structure1 implements Structure {Object[] objs = new Object[100];//使用内部类是为了对Struture1的数据结构有完全的访问权class Iteratora1 implements Iteratora {int index = 0;public void first(); {index = 0;}public boolean hasElement(); {return index < 100;} public Object next(); {Object obj = null;if (hasElement();); {obj = objs[index];index++;}return obj;}}}//Meditorclass A1 {public void operation1(); {}public void operation2(); {}}class A2 {public void operation1(); {}public void operation2(); {}}class Mediator {A1 a1;A2 a2;public Mediator(A1 a1, A2 a2); {this.a1 = a1;this.a2 = a2;}//如果我想实现这个功能我可能会把他放在A1中//但是这样耦合大，我不想在A1中出现A2对象的引用，//所以我使用了Mediator作为中介public void mmed1(); {a1.operation1();;a2.operation2();;}public void mmed2(); {a2.operation1();;a1.operation2();;}}//Command//我认为就是将方法转换成了类class Receiver {public void action1(); {}public void action2(); {}}interface Command {void Execute();;}class CCommand1 implements Command {private Receiver receiver;public CCommand1(Receiver receiver); {this.receiver = receiver;}public void Execute(); {receiver.action1();;}}class CCommand2 implements Command {private Receiver receiver;public CCommand2(Receiver receiver); {this.receiver = receiver;}public void Execute(); {receiver.action2();;}}//Observer//在这里看似乎这个模式没有什么用//但是如果我有一个线程监控Subject，如果Subject的状态//发生了变化，则更改Observer的状态，并出发一些操作，这样就有实际的意义了//Observer与Visitor有相似的地方，都存在双向引用//Subject可以注册很多Observerinterface Subjectb {void attach(Observer observer);;void detach(Observer observer);;void mynotify();;int getState();;void setState(int state);;}class Subjectb1 implements Subjectb {List observers = new ArrayList();;int state;public void attach(Observer observer); {observers.add(observer);;}public void detach(Observer observer); {observers.remove(observer);;}public void mynotify(); {Observer observer = null;Iterator it = observers.iterator();;while (it.hasNext();); {observer = (Observer); it.next();;observer.Update();;}}public int getState(); {return state;}public void setState(int state); {this.state = state;}}interface Observer {void Update();;}class Observer1 implements Observer {Subjectb subject;int state;public Observer1(Subjectb subject); {this.subject = subject;}public void Update(); {this.state = subject.getState();;}public void operation(); {//一些基于state的操作}}//Memento//感觉此模式没有什么大用class Memento {int state;public int getState(); {return state;}public void setState(int state); {this.state = state;}}class Originator {int state;public void setMemento(Memento memento); {state = memento.getState();;}public Memento createMemento(); {Memento memento = new Memento();;memento.setState(1);;return memento;}public int getState(); {return state;}public void setState(int state); {this.state = state;}}class careTaker {Memento memento;public void saverMemento(Memento memento); {this.memento = memento;}public Memento retrieveMemento(); {return memento;}}//程序最终还是顺序执行的，是由不通部分的操作拼接起来的//将不同类的代码拼接起来是通过引用实现的，有了引用我就//相当于有了一定访问数据结构和方法的能力，这与写在类内部//差不多，例如我想将一个类中的一个方法抽离出去，因为这个方法依赖与此类的数据和其他方法//直接将代码移走是不行的，但如果我们拥有了此类对象的引用，则与写在此类//内部无异，所以我们拥有了引用就可以将此方法移出public class tt1 {public static void main(String[] args); {}}?
转载：http://www.iteye.com/topic/19613