[最全]设计模式实战（七）装饰&享元&外观&桥接

装饰模式

定义及使用场景：

定义：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。比如：人穿着各式各样的衣服。

使用场景：需要透明且动态地扩展类的功能时。

基本用法：

1.Component：抽象组件。被装饰的抽象/原始对象。

2.ConcreteComponent：组件具体实现类。被装饰的具体对象。

3.Decorator：抽象装饰者。大多数情况下，为抽象类。

4.ConcreteDecoratorA：装饰者具体实现类。

public abstract class Component {
    /**
     * 抽象的方法，这个随你做
     * 同样地你也可以增加更多的抽象方法
     */
    public abstract void operate();
}

public class ConcreteComponent extends Component {
    @Override
    public void operate() {
        // 具体逻辑，这个随你做
    }
}

public abstract class Decorator extends Component {
    private Component component;// 持有—个Component对象的引用
    /**
     * 必要的构造方法 需要—个Component类型的对象
     * @param component Component对象
     */
    public Decorator(Component component) {
        this.component = component;
    }
    @Override
    public void operate() {
        component.operate();
    }
}

public class ConcreteDecoratorA extends Decorator {
    protected ConcreteDecoratorA(Component component) {
        super(component);
    }
    @Override
    public void operate() {
        // 装饰方法A和B既可在父类方法前调用也可在之后调用
        operateA();
        super.operate();
        operateB();
    }
    /**
     * 自定义的装饰方法A
     */
    public void operateA() {
        // 装饰方法逻辑……
    }
    /**
     * 自定义的装饰方法B
     */
    public void operateB() {
        // 装饰方法逻辑……
    }
}

public class Client {
    public static void main(String[] args) {
        // 构造被装饰的组件对象
        Component component = new ConcreteComponent();
        // 根据组件对象构造装饰者对象A并调用，此时相当于给组件对象增加装饰者A的功能方法
        Decorator decorator = new ConcreteDecoratorA(component);
        decorator.operate();
        // 根据组件对象构造装饰者对象B并调用，此时相当于给组件对象增加装饰者B的功能方法
        Decorator decoratorB = new ConcreteDecoratorB(component);
        decoratorB.operate();
    }
}

装饰模式实战：

人穿着各式各样的衣服。

public abstract class Person {
    /**
     * Person下有—个穿着的抽象方法
     */
    public abstract void dressed();
}

public class Boy extends Person {
    @Override
    public void dressed() {
        // Boy类下dressed方法的基本逻辑
        System.out.println("穿了内衣内裤");
    }
}

public abstract class PersonCloth extends Person {
    protected Person mPerson;// 保持—个Person类的引用
    public PersonCloth(Person mPerson) {
        this.mPerson = mPerson;
    }
    @Override
    public void dressed() {
        // 调用Person类中的dressed方法
        mPerson.dressed();
    }
}

public class CheapCloth extends PersonCloth {
    public CheapCloth(Person mPerson) {
        super(mPerson);
    }
    /**
     * 穿短裤
     */
    public void dressShorts() {
        System.out.println("穿条短裤");
    }
    @Override
    public void dressed() {
        super.dressed();
        dressShorts();
    }
}

public class Main {
    public static void main(String[] args) {
        // 首先我们要有—个Person男孩
        Person person = new Boy();
        // 然后为他穿上便宜的衣服，比如爱哥这样的Boy
        PersonCloth clothCheap = new CheapCloth(person);
        clothCheap.dressed();
        // 或者给他穿上比较上档次的衣服，如SM
//        PersonCloth clothExpensive = new ExpensiveCloth(person);
//        clothExpensive.dressed();
    }
}

安卓中的装饰模式：

Activity 与 Context 之间的关系就使用了装饰模式。

Context 是一个抽象类，它定义了应用程序的运行上下文环境。而 Activity 是 Context 的一个具体实现，它代表了一个具有用户界面的应用程序组件。

在 Android 源码中，Context 有以下几个装饰类：

• ContextThemeWrapper：用于设置 Activity 的主题。

• ContextWrapper：用于包装 Context 对象，提供一些额外的功能。

  </