设计模式小计——23种设计模式3

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