设计模式小计——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();
        }
    }