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 //此方法是一个TemplateMethod public 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(); } } //一个简单的生成产品的实现 //1 abstract 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 } } //2 interface 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 //一个类只有一个对象,例如一个线程池,一个cache class 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; } } 分类: 技术随笔, Java 绿色通道:好文要顶关注我收藏该文与我联系 落花人独立 关注 - 0 粉丝 - 4 +加关注 0 0 (请您对文章做出评价) « 博主前一篇:常用的40个网站制作技巧 (转) » 博主后一篇:状态对象:数据库的替代者 Feedback #1楼[楼主] 回复 引用 查看 2008-01-17 10:07 by 落花人独立 //**********结构型模式********** //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; } } //Proxy interface 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(); } } //Composite interface 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 before component.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 //空 #2楼[楼主] 回复 引用 查看 2008-01-17 10:11 by 落花人独立 //**********行为型模式************* //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 Method abstract 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; } } } //Meditor class 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可以注册很多Observer interface 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) { } }
23设计模式
猜你喜欢
转载自alexboy.iteye.com/blog/1197415
今日推荐
周排行