《设计模式之禅》读书笔记（五）-CSDN博客

本文链接：https://blog.csdn.net/hyz8884/article/details/54838054

一.装饰模式

定义：动态的给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。
四个角色：
Component 抽象构件是一个接口或者抽象类，就是定义我们最核心的对象，也就是最原始的对象。
ConcreteComponent 具体构件最核心，最原始，最基本的接口或抽象类的实现，你要装饰的就是它。
Decorator 装饰角色一个抽象类或者抽象方法，它的属性里必然有一个private 变量指向Component抽象构件。
ConcreteDecoratorA 具体装饰角色把最核心，最原始的，最基本的东西装饰成其他东西。
优点：
装饰类和被修饰类可以独立发展，而不会相互耦合。
装饰模式是继承关系的一个替代方案。
装饰模式可以动态的扩展一个实现类的功能。
缺点：
多层的装饰是比较复杂的。
使用场景：
需要扩展一个类的功能，或给一个类增加附加功能。
需要动态地给一个对象增加功能，这些功能可以动态的撤销。
需要为一批的兄弟类进行改装或加装功能。


public class DecoratorPatteern {
    public String getResult(){
        Component component = new ConcreteComponent();
        component = new ConcreteDecorator1(component);
        component = new ConcreteDecorator2(component);
        return  component.operate();
    }
}

/**
 * 抽象构件
 * Created by hyz84 on 17/1/5.
 */

public abstract class Component {
    //抽象的方法
    public abstract String operate();
}
/**
 *具体构件 最核心，最原始，最基本的接口或抽象类的实现，你要装饰的就是它
 * Created by hyz84 on 17/1/5.
 */
public class ConcreteComponent extends Component {
    @Override
    public String operate() {
        return "ConcreteComponent do Something!";
    }
}

/**装饰角色
 * Created by hyz84 on 17/1/5.
 */

public abstract class Decorator extends Component {
    private Component mComponent=null;
    public Decorator(Component _component){
        mComponent=_component;
    }
    @Override
    public String operate() {
        return mComponent.operate();
    }
}


/**
 * 具体装饰角色
 * Created by hyz84 on 17/1/5.
 */

public class ConcreteDecorator1 extends Decorator {
    //定义被修饰者
    public ConcreteDecorator1(Component _component) {
        super(_component);
    }
    //定义自己的方法
    private String method1(){
        return "methdo1 修饰";
    }
    public String operate(){
        return   method1()+super.operate();

    }
}

public class ConcreteDecorator2 extends Decorator {

    //定义被修饰者
    public ConcreteDecorator2(Component _component) {
        super(_component);
    }
    //定义自己的方法
    private String method1(){
        return "methdo2 修饰";
    }
    public String operate(){
        return   method1()+super.operate();

    }
}

二.策略模式

定义：定义一组算法，将每个算法都封装起来，并且使它们之间可以互换
* 策略模式三个角色：
* Context封装角色：
* 它也叫上下文角色，起承上启下封装作用，屏蔽高层模块对策略，算法的直接访问，封装可能存在变化。
* Strategy 抽象策略角色：
* 策略算法家族的抽象，通常为接口，定义每个策略或算法必须具有的方法和属性。
* ConcreteStrategy1 具体策略角色
*优点：
* 1.算法可以自由切换
* 2.避免多重条件判断
* 3.扩展性良好
* 缺点：
* 1.策略类数量增多
* 2.所有策略都需要对外暴露
* 使用场景：
* 1.多个类只有在算法或行为上稍有不同的场景
* 2.算法需要自由切换的场景
* 3.需要屏蔽算法规则的场景

public class StrategyPattern {
    Strategy mStrategy=null;
    StrategyContext mStrategyContext;
    public String  excuStrategy1(){
        mStrategy = new ConcreteStrategy1();
        mStrategyContext = new StrategyContext(mStrategy);
        return mStrategyContext.doAnything();
    }

    public String  excuStrategy2() {
        mStrategy = new ConcreteStrategy2();
        mStrategyContext = new StrategyContext(mStrategy);
        return mStrategyContext.doAnything();
    }

    public String  excuStrategy3(String symbol,int a,int b){
        switch (symbol){
            case "+":
                return "计算结果："+   Calculator.ADD.exec(a,b);

            case "-":
                return "计算结果："+  Calculator.SUB.exec(a,b);
            default:
                return "";
        }

    }
}
/**
 * 抽象策略
 * Created by hyz84 on 17/1/8.
 */

public interface Strategy {
    //策略模式的运算法则
    public String doSomething();
 }

public class ConcreteStrategy1 implements Strategy {
    @Override
    public String doSomething() {
        return "具体策略1的运算法则";
    }
}

public class ConcreteStrategy2 implements Strategy {
    @Override
    public String doSomething() {
        return "具体策略2的运算法则";
    }
}

/**策略上下文
 * Created by hyz84 on 17/1/8.
 */

public class StrategyContext {
    private Strategy mStrategy=null;
    public StrategyContext(Strategy _strategy){
        mStrategy = _strategy;
    }
    //封装后的策略方法
    public String doAnything(){
        return   mStrategy.doSomething();
    }
}
/**************************************************************/
/**
 * 策略枚举
 * Created by hyz84 on 17/1/8.
 */

public enum Calculator {
    //加法
    ADD ("+"){
        public int exec(int a,int b){
            return a+b;   }
    },
    //减法
    SUB("-"){
        public int exec(int a,int b){
            return a-b;
        }
    };
    String  mValue="";
    //定义成员值类型
    private Calculator(String _value){
        mValue=_value;
    }
    //获得枚举成员的值
    public String getValue(){
        return mValue;
    }

    public abstract int exec(int a,int b);
}

三.适配器模式

定义：将一个累的接口变化成客户端所期待的另一种接口，
从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。
角色：
Target 目标角色该角色定义把其他类转换为我们的期望接口
Adaptee 源角色
Adapter 适配器角色把源角色转换为目标角色，通过继承或是关联的方式。
优点：
适配器模式可以让两个没有任何关系的类在一起运行
增加类的透明性
提高了类的复用度
灵活性非常好


public class AdapterPattern {
    public String excu(){
        Target target = new ConcreteTarget();
        target.request();
        Target target2 = new Adapter();
          return target.request()+"\n"+target2.request();
    }
}

public interface Target {
    //目标角色有自己的方法
    public String request();
}

public class ConcreteTarget implements Target {
    @Override
    public String request() {
        return "This is ConcreteTarget! ";
    }
}

public class Adapter extends Adaptee implements Target {
    @Override
    public String request() {
        return super.doSomethig();
    }
}

public class Adaptee {
    //原有业务逻辑
    public String doSomethig(){
        return "This is 源角色";
    }
}

四.迭代器模式

定义：提供一个方法访问一个容器对象中各个元素，而又不暴露该对象内部的细节
角色：
Iterator：抽象迭代器
ConcreteIterator 具体迭代器
Aggregate 抽象容器
ConcreteAggregate 具体迭代器
使用：一般不需要自己写迭代器


public class IteratorPattern {
    public String doSomething(){
        Aggreate aggreate = new ConcreteAggregate();
        aggreate.add("abc");
        aggreate.add("xyz");
        Iterator iterator  = aggreate.iterator();
        String result="";
        while (iterator.hasNext()){
            result+=iterator.next();
        }
        return result;
    }
}


public interface Iterator {
    //遍历下一个元素
    public Object next();
    //判断是否已经遍历到尾部
    public boolean hasNext();
    //删除当前指向的元素
    public boolean remove();
}

public class ConcreteIterator implements Iterator {

    private Vector mVector = new Vector();
    //定义当前游标
    public int cursor=0;

    public ConcreteIterator(Vector _vector){
        mVector=_vector;
    }

    @Override
    public Object next() {
        Object result = null;
        if(hasNext()){
            result=mVector.get(cursor++);
        }

        return result;
    }

    @Override
    public boolean hasNext() {
        if(cursor==mVector.size()){
            return false;
        }
        return true;
    }

    @Override
    public boolean remove() {
        mVector.remove(cursor);
        return true;
    }
}

public interface Aggreate {
    //添加元素
    public void add(Object object);
    //减少元素
    public void remove(Object object);
    //由迭代器来遍历所有元素
    public Iterator iterator();
}


public class ConcreteAggregate implements Aggreate {
    //容纳对象的容器
    private Vector mVector = new Vector();
    @Override
    public void add(Object object) {
        mVector.add(object);
    }

    @Override
    public void remove(Object object) {
        mVector.remove(object);
    }

    @Override
    public Iterator iterator() {
        return new ConcreteIterator(mVector);
    }
}

五.组合模式

定义：将对象组合成树形结构以表示”部分—整体”的层次结构使得用户对单个对象和组合对象的使用具有一致性。
角色：
Component 抽象构件角色定义参加组合对象的共有方法和属性，可以定义一些默认行为或属性；
Leaf 叶子构件叶子对象，其下再也没有其他的分支
Composite 树枝构件树枝对象，它的作用是组合树枝节点和叶子节点形成一个树状结构
优点：高层模块调用简单，节点自由增加
缺点：直接定义了树叶和树枝的实现类，与依赖倒置原则冲突
使用场景：
维护和展示部分-整体关系的场景，如树形菜单，文件和文件夹管理
从一个整体中能够独立出部分模块或功能的场景

public class CompositePattern {
    StringBuffer mBuffer = new StringBuffer();
    public String showExample() {

        Composite root = new Composite();
        mBuffer.append(root.doSomething() + "\n");
        Composite branch = new Composite();
        Leaf leaf = new Leaf();
        root.add(branch);
        branch.add(leaf);
        display(root);
        return mBuffer.toString();
    }
    private void display(Composite _root){
        for (Component component:_root.getChildren()){
            if(component instanceof  Leaf){
                mBuffer.append( component.doSomething()+"\n");
            }else{
                display((Composite)component);
            }
        }
    }
}

public abstract class Component {
    //个体和整体都具有的共享
    public String doSomething(){
        //业务逻辑
        return "Component";
    }
}

/**
 * 树枝构件
 * Created by hyz84 on 17/1/10.
 */
public class Composite extends Component {
    private ArrayList<Component> mComponentArrayList = new ArrayList<>();

    /**
     * 增加一个叶子构件或者树枝构件
     *  @param _component
     */
    public void add(Component _component) {
        mComponentArrayList.add(_component);
    }

    public void remove(Component _component){
        mComponentArrayList.remove(_component);
    }

    public ArrayList<Component> getChildren(){
        return mComponentArrayList;
    }
}

/**树叶构件
 * Created by hyz84 on 17/1/10.
 */
public class Leaf extends Component {
    /**
     * 可以复写父类方法
     * @return
     */
    public  String doSomething(){
        return "leaf ";
    }
}

六.观察者模式

也叫订阅模式(publish/subscribe)
* 定义：定义对象间的一种一对多的依赖关系，使得每当一个对象改变状态，
* 则所有依赖于它的对象都会得到通知并被自动更新。
* 角色：
* Subject 被观察者定义被观察者必须实现的职责，他必须能动态的增加，取消观察者。
* Oberver 观察者观察者接收到消息后，即进行update操作，对接收到信息进行处理。
* ConcreteSubject 具体的被观察者
* ConcreteObserver 具体的观察者

public class ObserverPattern {

    public  void excuExample(){
        tempBuffer.delete(0,tempBuffer.length());
        ConcreteSubject subject = new ConcreteSubject();
        Observer mOberver = new ConcreteObserver();
        subject.addObserver(mOberver);
        subject.doSomething();
    }
}
public abstract class Subject {
    //定义一个观察者集合
    private Vector<Observer> mObservers = new Vector<>();
    //添加一个观察者
    public void addObserver(Observer _observer){
        mObservers.add(_observer);
    }
    //删除一个观察者
    public void delObserver(Observer _observer){
        mObservers.remove(_observer);
    }
    //通知所有观察者
    public void notifyObservers(){
        for(Observer o:mObservers){
            o.update();
        }
    }
}
public class ConcreteSubject extends Subject {
    public void doSomething(){
        super.notifyObservers();
        tempBuffer.append("ConcreteSubject doSomething！ \n");
    }
}
public interface Observer {
    //更新方法
    public void update();
}

public class ConcreteObserver implements Observer {
    @Override
    public void update() {
        tempBuffer.append("ConcreteObserver,收到信息，并进行处理\n");
    }
}

七.门面模式

门面模式 Facade Pattern ,也叫外观模式。
* 定义：要求一个子系统的外部与其内部通信必须通过一个统一的对象进行。
* 简单的说，门面对象是外部访问子系统内部唯一的通道。
* 角色：
* Facade门面角色
* subsystem 子系统角色
* 优点：
* 减少系统的相互依赖
* 提高了灵活性
* 提高安全性
* 缺点：不符合开闭原则
* 使用场景：为一个复杂的模块或子系统提供一个供外界访问的接口
* 子系统相对独立
* 预防低水平人员带来的风险扩散


public class FacadePattern {
    public void excuSample(){
        Facade mFacade = new Facade();
        mFacade.methodA();
        mFacade.methodB();
        mFacade.methodC();
    }
}

/**
 * 门面
 * Created by hyz84 on 17/1/11.
 */

public class Facade {
    //被委托对象
    private SubSystem.ClassA mA = new SubSystem.ClassA();
    private SubSystem.ClassB mB = new SubSystem.ClassB();
    private SubSystem.ClassC mC = new SubSystem.ClassC();

    //提供给外部访问的方法
    public void methodA() {
        mA.doSomething();
    }

    public void methodB() {
        mB.doSomething();
    }

    public void methodC() {
        mC.doSomething();
    }
}

/**
 * 子系统
 * Created by hyz84 on 17/1/11.
 */

public class SubSystem {
    public static class ClassA{
        public void doSomething(){
            tempBuffer.append("classA A A 。。。\n");
        }
    }
    public static class ClassB{
        public void doSomething(){
            tempBuffer.append("classB B B 。。。\n");
        }
    }
    public static class ClassC{
        public void doSomething(){
            tempBuffer.append("classC C C 。。。");
        }
    }
}

八.备忘录模式

备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
- 这样以后就可以将该对象恢复到原先保存状态。通俗的说就是一个对象的备份模式，
- 提供一种程序数据的备份方法。
- 备忘录模式的角色：
- Originator:发起人角色记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。
- Memento：备忘录角色负责存储Originator发起人对象的内部状态，在需要的时候提供发起人需要的内部状态。
- Caretaker:备忘录管理员角色对备忘录进行管理、保存和提供备忘录
  *使用场景：
- 1.需要保存和恢复数据的相关场景
- 2.提供一个可回滚的操作
- 3.需要监控的副本场景中
- 4.数据库连接的事物
- 注意事项：
- 备忘录的生命周期，备忘录的性能

public class MementoPattern {
    public void execuExample(){
        tempBuffer.delete(0,tempBuffer.length());
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();
        originator.setState("First State!");
        caretaker.setMemento(originator.createMemento());
        originator.setState("Second State!");
        originator.restoreMemento(caretaker.getMemento());
        String state = originator.getState();
        tempBuffer.append("恢复：current state:"+state);
    }
}

/**
 * 发起人角色
 * Created by apple on 17-1-31.
 */

public class Originator {
    //内部状态
    private String state="1";

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
        tempBuffer.append("current state:"+state);
    }

    /**
     * 创建一个备忘录
     * @return
     */
    public Memento createMemento(){
        return new Memento(state);
    }

    /**
     * 恢复备忘录
     * @param _memento
     */
    public void restoreMemento(Memento _memento){
        this.setState(_memento.getState());
    }
}

/**
 * 备忘录角色
 * Created by apple on 17-1-31.
 */

public class Memento {
    private String state="";
    public Memento(String _state){
        this.state=_state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

/**
 * 备忘录管理员角色
 * Created by apple on 17-1-31.
 */

public class Caretaker {
    private Memento memento;
    public Memento getMemento(){
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

九.访问者模式

访问者模式：封装一些作用于某种数据结构中的各种元素操作，他可以在不改变数据结构的前提下作用于这些元素的新的操作。
* 角色:
* Visitor 抽象访问者:抽象类或者接口，声明访问者可以访问哪些元素；
* ConcreteVisitor 具体访问者
* Element 抽象元素接口或者抽象类，声明接受哪一类访问者访问，程序上通过accept方法中的参数来定义的。
* ConcreteElement 具体元素实现accept方法，通常是visitor.visit(this)
* ObjectStruture 结构对象元素产生者，一般容纳在多个不同类，不同接口的容器
*
* 优点：符合单一职责原则
* 优秀的拓展性
* 灵活性非常高
* 缺点：具体元素变更比较困难
* 具体元素对访问者公布细节
* 违背了依赖倒置原则
* 使用场景：一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。
* 需要对一个对象结构中的对象进行很多不同并且不相关的操作，而你想避免这些操作”污染”这些对象的类。
* 总而言之，在这种情况下一定要考虑使用访问者模式：业务规则要求遍历多个不同的对象。
* 最佳实践：访问者模式是一种集中规整模式，特别适用于大规模重构项目


public class VisitorPattern {
    public  void excuExample(){
        for(int i=0;i<10;i++){
            Element element = ObjectStructure.createElement();
            element.accept(new Visitor());
        }
    }
}
/**
 * 抽象元素
 * Created by apple on 17-1-31.
 */

public abstract class Element {
    public abstract void doSomething();
    public abstract void accept(IVisitor _visitor);
}
/**
 * 具体元素
 * Created by apple on 17-1-31.
 */

public class CocreteElement1 extends Element {
    @Override
    public void doSomething() {
        //业务逻辑
        tempBuffer.append("CocreteElement1 dothing");
    }

    /**
     * 允许那个访问者访问
     * @param _visitor
     */
    @Override
    public void accept(IVisitor _visitor) {
        _visitor.visit(this);
    }
}
/**
 * 具体元素
 * Created by apple on 17-1-31.
 */

public class CocreteElement2 extends Element {
    @Override
    public void doSomething() {
        //业务逻辑
        tempBuffer.append("CocreteElement2 dothing");
    }

    /**
     * 允许那个访问者访问
     * @param _visitor
     */
    @Override
    public void accept(IVisitor _visitor) {
        _visitor.visit(this);
    }
}

/**
 * 抽象访问者
 * Created by apple on 17-1-31.
 */

public interface IVisitor {
    public void visit(CocreteElement1 element);
    public void visit(CocreteElement2 element);
}
/**
 * Created by apple on 17-1-31.
 */

public class Visitor implements IVisitor {
    /**
     * 访问element1
     * @param element
     */
    @Override
    public void visit(CocreteElement1 element) {
        element.doSomething();
    }

    /**
     * 访问Element2
     * @param element
     */
    @Override
    public void visit(CocreteElement2 element) {
        element.doSomething();
    }
}

/**
 * 结构对象
 * Created by apple on 17-1-31.
 */

public class ObjectStructure {
    /**
     * 对象生成器
     * @return
     */
    public static Element createElement(){
        Random rand = new Random();
        if(rand.nextInt(100)>50){
            return new CocreteElement1();
        }else{
            return new CocreteElement2();
        }
    }
}

十.状态模式

状态模式：当一个对象内部状态改变时，允许其改变行为，
这个对象看起来像改变了其类。
角色：
State ：抽象状态角色接口或抽象类，负责对象状态定义，并且
封装环境角色以实现状态切换。
ConcreteState: 具体状态角色每一个具体状态必须完成两个职责
本状态行为管理以及趋向状态处理，通俗说就是：本状态下要做的事情
和如何过度到下一个状态。
Context：环境角色定义客户端需要的接口，并且负责具体状态的切换
把状态对象声明为静态常量，有几个状态对象就声明几个静态常量。
环境角色具有状态抽象角色定义的所有行为，具体执行使用委托方式
优点:结构清晰
遵循设计原则
封装性非常好
缺点：子类太多，类膨胀
使用场景：行为随状态改变而改变的场景
条件、分支判断语句的替代者

public class StatePattern {

    public void excuExample(){
        //定义环境变量
        MyContext context = new MyContext();
        //初始化状态
        context.setCurrentState(new ConcreteState1());
        //行为执行
        context.handle1();
        context.handle2();
    }
}
/**
 * 抽象环境角色
 * Created by apple on 17-2-1.
 */

public abstract class State {
    //定义一个环境角色，提供子类访问
    protected  MyContext context;
    //设置环境角色
    public void setContext(MyContext _context){
        this.context=_context;
    }
    //行为1
    public abstract void handle1();
    //行为2
    public abstract  void  handle2();
}
/**
 * Created by apple on 17-2-1.
 */

public class ConcreteState1 extends State {
    @Override
    public void handle1() {
        //本状态下必须处理的逻辑

        tempBuffer.append("ConcreteState1,dothing\n");
    }

    @Override
    public void handle2() {
        //设置当前状态为state2
        super.context.setCurrentState(MyContext.STATE2);
        //过渡到state2，由Context实现
        super.context.handle2();
    }
}
public class ConcreteState2 extends State {
    @Override
    public void handle1() {
        //设置当前状态为state1
        super.context.setCurrentState(MyContext.STATE1);
        //过渡到state2，由Context实现
        super.context.handle1();
    }

    @Override
    public void handle2() {
        //本状态下处理的业务逻辑
        tempBuffer.append("ConcreteState2,dothing\n");
    }
}
public class ConcreteState2 extends State {
    @Override
    public void handle1() {
        //设置当前状态为state1
        super.context.setCurrentState(MyContext.STATE1);
        //过渡到state2，由Context实现
        super.context.handle1();
    }

    @Override
    public void handle2() {
        //本状态下处理的业务逻辑
        tempBuffer.append("ConcreteState2,dothing\n");
    }
}

十一.解释器模式

解释器模式：给定一门语言，定义它的文法的一种表示，并定义一个解释器，
该解释器使用该表示来解释语言
在实际的系统开发中使用的非常少,而且有各种开源解析工具包

十二.享元模式

享元模式 Flyweight Pattern 是池技术的重要实现方式
使用共享对象可有效地支持大量的细粒度的对象。
对象的内部状态和外部状态
内部状态 intrinsic：内部状态是对象可共享出来的信息，
存储在享元对象内部并且不随环境改变而改变。
外部状态 extrinsic :外部状态是对象得以依赖的一个标记，是随环境改变而改变的
角色：
Flyweight:抽象享元角色一个产品的抽象类，同时定义出对象的外部状态和内部状态的接口或实现。
ConcreteFlyweight:具体享元角色
unsharedConcreteFlyweight:不可共享的享元角色
FlyweightFactory:享元工厂构建一个池容器，同时提供从池中获取对象的方法
*
使用场景：系统中存在大量的相似对象；
细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关
需要缓冲池的场景

public class FlyweightPattern {
}
/**
 * 抽象享元角色
 * Created by apple on 17-2-1.
 */

public abstract class Flyweight {
    //内部状态
    private String intrinsic;
    //外部状态
    protected  final String extrinsic;
    //要求享元角色必须接受外部状态
    public Flyweight(String _extrinsic){
        extrinsic=_extrinsic;
    }
    //定义业务操作
    public abstract void operate();

    public String getIntrinsic() {
        return intrinsic;
    }

    public void setIntrinsic(String intrinsic) {
        this.intrinsic = intrinsic;
    }
}
public class ConcreteFlyweight1 extends Flyweight {
    //接受外部状态
    public ConcreteFlyweight1(String _extrinsic){
        super(_extrinsic);
    }

    @Override
    public void operate() {
        //业务逻辑
    }
}
public class ConcreteFlyweight2 extends Flyweight {
    //接受外部状态
    public ConcreteFlyweight2(String _extrinsic){
        super(_extrinsic);
    }

    @Override
    public void operate() {
        //业务逻辑
    }
}
public class FlyweightFactory {
    //定义一个池容器
    private static HashMap<String,Flyweight> pool = new HashMap<>();
    //享元工厂
    public static Flyweight getFlyweight(String extrinsic){
        //需要返回的工厂
        Flyweight flyweight=null;
        if(pool.containsKey(extrinsic)){
            flyweight =pool.get(extrinsic);
        }else{
            flyweight = new ConcreteFlyweight1(extrinsic);
            pool.put(extrinsic,flyweight);

        }
        return flyweight;
    }
}

十三.桥梁模式

桥梁模式也叫桥接模式将抽象和实现解耦，使得两者可以独立的变化
角色：
Abstraction:抽象化角色，定义出该角色的行为，同时保存一个对实现化角色的应用，一般抽象类。
Implementor:实现化角色接口或者抽象类，定义角色必须的行为和属性
RefinedAbstraction:修正抽象化角色它引用实现化角色对抽象化角色进行修正。
ConcreteImplementor:具体实现化角色


public class BridgePattern {

    public void excuExample(){
        Implementor implementor = new ConcreteImplementor1();
        Abstraction abstraction = new RefinedAbstraction(implementor);
        abstraction.request();
    }
}
/**
 * 实现化角色
 * Created by apple on 17-2-1.
 */

public interface Implementor {
    //基本方法
    public void doSomething();
    public void doAnything();
}
/**
 * 抽象化角色
 * Created by apple on 17-2-1.
 */

public abstract class Abstraction {
    //定义对实现化角色的引用
    private Implementor implementor;
    public Abstraction(Implementor _imp){
        implementor=_imp;
    }
    //自身行为和属性
    public void request(){
        this.implementor.doSomething();
    }

    /**
     * 获取实现化角色
     * @return
     */
    public Implementor getImplementor() {
        return implementor;
    }
}
/**
 * Created by apple on 17-2-1.
 */

public class ConcreteImplementor1 implements Implementor {
    @Override
    public void doSomething() {
        tempBuffer.append("ConcreteImplementor1 doSomething\n");
    }

    @Override
    public void doAnything() {
        tempBuffer.append("ConcreteImplementor1 doAnything\n");
    }
}
public class ConcreteImplementor2 implements Implementor {
    @Override
    public void doSomething() {
        tempBuffer.append("ConcreteImplementor2 doSomething\n");
    }

    @Override
    public void doAnything() {
        tempBuffer.append("ConcreteImplementor2 doAnything\n");
    }
}
public class RefinedAbstraction extends Abstraction {
    //复写构造函数
    public RefinedAbstraction(Implementor _imp) {
        super(_imp);
    }

    /**
     * 修正父类行为
     */
    @Override
    public void request() {
        //业务处理

        tempBuffer.append("RefinedAbstraction request\n");
        super.request();
        super.getImplementor().doAnything();
    }
}