首页 > 代码库 > 设计模式小计——23种设计模式3
设计模式小计——23种设计模式3
责任链模式Chain of Responsibility 使多个对象都有机会处理请求,从而避免请求的发送者和接受者间的耦合关系,并沿着这条链传递请求,直到有对象处理它为止 责任链模式关键是建立链接关系,在链中决定谁来处理请求 //抽象处理者 public abstract class Handle{ private Handle nextHandle;//链的下一个节点 public final Response handleMessage(Request request){ Response response = null; if(this.getHandlerLevel().equals(request.getRequestLevel())){ response=this.echo(request); } else{ if(this.nextHandle != null){ response = this.nextHandle.handleMessage(request); } else{//没有适当处理者,自行处理} } return response; } public void setNext(Handle handle){this.nextHandle=handle;} protected abstract Level getHandlerLevel();//每个处理者都有一个处理级别,对应链中位置 protected abstract Response echo(Request request);//每个处理这都有处理任务 } //处理级别 public class Level{} //请求类 public class Request{ public Level getRequestLevel(){}//获取请求级别 } //回显类 public class Response(){}//返回处理后的数据 请求和处理分离,提高系统灵活性 性能不佳,调试不便 装饰模式Decorator Pattern 动态为一个对象添加一些额外的职责 //基本抽象类 public abstract class Component{ public abstract void action(); } //具体工作类 public class ConcreteComponent extends Component{ @Override public void action(){}//具体实现方法 } //抽象装饰类 public Decorator extends Component{ private Component component = null; public Decorator(Component component){this.component=component;} @Override public void action(){ this.component.action(); } } //具体装饰类 public ConcreteDecorator extends Component{ public ConcreteDecorator(Component component){super(component);} private void method(){}//装饰方法 public void action(){//重写父类action方法 this.method(); super.action(); } } 可以添加多个装饰类,层级嵌套,多层次装饰会提高系统复杂度 装饰模式可以替代继承,解决类膨胀问题 策略模式Strategy Pattern 定义一组算法,将每个算法都封装起来,并且可以使他们之间相互转换 //抽象算法 public interface Strategy{ public void doSomething(); } //具体算法类 public class ConcreteStrategy implements Strategy{ public void doSomething(){} } //封装算法 public class Context{ private Strategy strategy = null; public Context(Strategy strategy){this.strategy=strategy;} public void doAnything(){//封装后的算法方法 this.strategy.doSomething(); } } 适配器模式Adapter Pattern 将一个类的接口变换成客户端期待的另一种接口,从而使原本因接口不匹配而无法一起工作的两个类一起工作 //目标角色 public interface Target{ public void request();//目标方法 } //实际目标角色 public class ConcreteTarget implements Target{ public void request(){} } //源角色 public class Source{ public void method();//源方法 } //适配器类 public class Adapter extends Source implements Target{ public void request(){ super.method(); } } 适配器可以让两个没有任何关系的类在一起运行,提高类复用性,灵活性非常高 类对象适配器通过对源角色的继承完成拼接,即extends Source 对象适配器通过对源角色对象的关联完成拼接,即private Source source 适配器模式是一个补救模式,用于解决扩展应用时出现的接口不兼容问题 迭代器模式Iterator Pattern 提供一种方法访问容器对象的各个元素而又不暴露该对象内部细节 //抽象迭代器 public interface Iterator{ public Object next();//遍历到下一个元素 public boolean hasNext();//是否遍历到尾部 public boolean remove();//删除当前指向元素 } //具体迭代器 public class ConcreteIterator extends Iterator{ private Vector vector = new Vector(); public int cursor = 0;//定义当前游标 public ConcreteIterator(Vector vector){this.vector = vector;} public boolean hasNext(){ if(this.cursor == this.vector.size()){ return false; } return true; } public Object next(){ Object result = null; if(this.hasNext()){ result = this.vector.get(this.cursor++); }else{ result = null; } return result; } public boolean remove(){ this.vector.remove(this.cursor); return true; } } 迭代器模式在现代语言中得到广泛应用 组合模式Composite Pattern 将对象组合成树形结构以表示“部分-整体”的层次结构,使得用户对单个对象和组合对象的使用具有一致性 //抽象构件类 public abstract class Component{ public void doSomething(){}//共有业务逻辑 } //树枝构件 public c1ass Composite extends Component{ private ArrayList<Component> componentArray = new ArrayList<Component>();//构件容器 public void add(Component component){this.componentArray.add(component);}//增删容器 public void remove(Component component){this.componentArray.remove(component);} pubic ArrayList<Component> getChildren(){ return this.componentArray; } } //树叶构件 pubic class Leaf extends Component{ public void doSomething(){} } 高层模块调用简单,节点可以自由增加,符合开闭原则 在实际场景中需要直接使用实现类,无法使用抽象,违背依赖倒置原则 观察者模式Observer Pattern 定义对象间一对多的依赖关系,使得每当一个对象改变状态,所有依赖它的对象都得到通知自动更新 //抽象观察者类 public abstract class Observer{ public abstract void update(); } //具体观察者 public class ConcreteObserver{ public void update(){//} } //抽象被观察者 pubic abstract class Subject{ private Vector<Observer> observers = new Vector<Observer>(); public void add(Observer component){this.observers.add(component);}//增删容器 public void remove(Observer component){this.observers.remove(component);} public void notify(){ for(Observer 0:this.observers){ o.update(); } } } //具体被观察者 public class ConcreteSubject{ public void doSomething(){}//具体业务 } 观察者和被观察者抽象耦合 外观模式Facade Pattern 子系统的外部与其内部通信必须通过一个统一的对象进行,外观模式通过提供一个高层次接口,使得子系统更易于使用 //子系统 pubic class Class1{public void method();} pubic class Class1{public void method();} pubic class Class1{public void method();} //外观对象 public class Facade{ private Class1 c1 = new Class1(); private Class1 c2 = new Class2(); private Class1 c3 = new Class3(); public void method1(){ //子系统业务处理 } } 和中介者模式很像?中介者模式是让两个类不直接发生关系,而是通过中介者联系,中介者并不偏向于任一方,双方通过中介者互相和另一方发生关系,关系是双向的;外观模式也是让两个类不直接发生关系,但是外观偏向于某一方,另一方通过外观和某一方发生关系,但某一方不一定甚至不会通过外观和另一方发生关系,也就是关系偏向于单向关系 减少系统相互依赖,提高灵活性,安全性。 不符合开闭原则,对修改关闭,对扩展开放 备忘录模式Memento Pattern 在不破坏封装性的前提下,捕获一个对象内部状态。并在该对象之外保存这个状态,一边以后可以将之恢复 根据单一职责原则,备份行为应该交由另一个类来完成 //需要备份类 public class Originator{ private Stirng state = "";//内部状态 public void setState(){this.state = state;} public void getState(){return this.state;} public Memento createMemento(){ return new Memento(this.state); } public void restoreMemento(Memento memento){ this.setState(memento.getState); } } //备忘录角色,可以保存多个状态 public class Memento{ private String state; public Memento(String state){this.state = state;} public void setState(){this.state = state;} public void getState(){return this.state;} } //备忘录管理员角色,可以保存多个备忘录 public class Caretaker{ private Memento memento; public Memento getMemento(){ return memento; } public void setMemento(Memento memento){ this.memento = memento; } } 访问者模式Visitor Pattern 封装一些作用于某种数据结构的各元素的操作,它可以在不改变数据结构的前提下定义作用于这些元素的新的操作 即把操作数据的方法独立封装在单独的类中,使之可以动态修改操作 //抽象元素 pubic abstract class Element{ pubic abstract void doSomething(); public abstract void accept(IVisitor visitor); } //具体元素 pubic class ConcreteElement extends Element{ public void doSomething(){}//业务逻辑 public void accept(IVisitor visitor){visitor.visit(this);} } //抽象访问者 pubic interface class IVisitor{ pubic void visit(ConcreteElement el); } //具体访问者 pubic class Visitor implements IVisitor{ pubic void visit(ConcreateElement el){el.doSomething();} } 符合单一职责原则,易于扩展,灵活性高 违背依赖倒置原则,访问者依赖具体元素而不是抽象。 具体元素对访问者公布细节,违背迪米特原则 状态模式State Pattern 当一个对象内在状态改变时允许其改变行为,从外部看好像这个对象对应的类发生了改变一样 //抽象状态 pubic abstract class State{ protected Context context;//定义一个环境角色 public void setContext(Context context){this.context=context;} //行为1 public abstract void Handle1(); //行为2 public abstract void Handle2(); } //具体状态 pubic class ConcreteState1 extends State{ public void Handle1(){//内部逻辑} public void Handle2(){ //设置当前状态为state2 super.context.setCurrentState(Context.STATE2); super.context.handle2(); } } pubic class ConcreteState2 extends State{ public void Handle1(){ super.context.setCurrentState(Context.STATE1); super.context.handle1(); } public void Handle2(){//内部逻辑} } //环境角色 public class Context{ public final static State STATE1 = new ConcreteState1(); public final static State STATE2 = new ConcreteState2(); private State currentState;//当前状态 pubic State getCurrentState(){return currentState;} public void setCurrentState(State state){ this.currentState=state; this.currentState.setContext(this); } //行为委托 public void Handle1(){ this.currentState.handle1(); } public void Handle2(){ this.currentState.Handle2(); } } 简化状态判断语句的使用,提高系统可维护性。 遵循开闭原则和单一职责原则 解释器模式Interpreter Pattern 给定一门语言,根据文法表示,定义解释器可以解释语言中句子 享元模式Flyweight Pattern 使用共享对象可有效支持大量细粒度对象 //抽象享元角色 pubic abstract class FlyWeight{ //内部状态 private String intrinsic; //外部状态 protected final String Extrinsic; //要求享元角色必须接受外部状态 public FlyWeight(String Extrinsic){ this.Extrinsic=Extrinsic; } //定义业务操作 public abstract void operator(); //内部状态getter/setter } //具体享元角色 pubic class ConcreteFlyWeight extends FlyWeight{ public ConcreteFlyWeight(String Extrinsic){ super(Extrinsic); } pubic void operator(){//业务逻辑} } //享元工厂 pubic class FlyWeightFactory{ private static HashMap<String,FlyWeight> pool = new HashMap<String,FlyWeight>(); //享元工厂 public static FlyWeight getFlyWeight(String Extrinsic){ FlyWeight flyweight=null; if(pool.containsKey(Extrinsic)){ flyweight = pool.get(Extrinsic); }else{ flyweight = new ConcreteFlyWeight(Extrinsic); pool.put(Extrinsic,flyweight)l } return flyweight; } } 桥梁模式Bridge Pattern 将抽象和实现解耦,使得两者可以独立变化 //实现化角色 pubic interface Implementor{ public void doSomething(); } //具体实现化角色 pubic class ConcreteImplementor{ public void doSomething(); } //抽象化角色 pubic abstract class Abstraction{ private Implementor imp;//实现化角色引用 pubic Abstraction(Implementor imp){this.imp = imp;}//约束子类必须实现该构造方法 public Implementor getImp(){return imp;} //自身的行为和属性 public void request(){ this.imp.doSomething(); } } //具体抽象化角色 pubic class RefinedAbstraction extends Abstraction{ public RefinedAbstraction(Implementor imp){super(imp);} //修正父类方法 public void request(){ super.request(); super.getImp().doSomething(); } }
声明:以上内容来自用户投稿及互联网公开渠道收集整理发布,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任,若内容有误或涉及侵权可进行投诉: 投诉/举报 工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。