二十、装饰设计模式

1. 装饰设计模式介绍

定义

动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。

2. 装饰设计模式使用场景

动态地给一个对象添加一些额外的职责。

3. 装饰设计模式UML类图

角色介绍：

• Component:抽象组件，充当的是被装饰的原始对象。
• ConcreteComponent:组件具体实现类。
• Decotor:抽象装饰类：职责就是为了装饰组件对象，内部有一个指向组件对象的引用。
• ConcreteDecoratorA:装饰者的具体实现类
• Client：测试类

4. 装饰设计模式简单实现

• (1)、首先定义一个抽象组件类：

public abstract class Component {

    /**
     * 抽象的方法
     */
    public abstract void operation();
}

抽象组件类里面只有一个抽象方法operation()

• (2)、组件具体实现类：

public class ConcreteComponent extends Component {
    @Override
    public void operation() {
    }
}

组件具体实现类继承自组建抽象类，在operation方法里面有具体的实现逻辑。

• (3)、抽象装饰者：

public class Decorator extends Component {
    private Component component;//持有一个component对象的引用

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        component.operation();
    }
}

抽象装饰者类也继承自Component类，在构造函数里面接收一个Component类型的Component对象的引用，在operation()方法里面调用component的operation方法。

• (4)、装饰者实现类：

  ConcreteDecoratorA 和 ConcreteDecoratorB只是operation方法调用父类operation方法的顺便不同而已。

public class ConcreteDecoratorA extends Decorator {

    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        opetateA();
        super.operation();
        opetateB();
    }

    private void opetateB() {

    }

    private void opetateA() {

    }
}   

装饰者实现类里面，继承自Decorator类，在operation方法里面会调用父类operation方法，也可以自己进行相关逻辑操作。

• (5)测试类：

public class Client {
    public static void main(String[] args) {
        //构造被装饰的组件对象
        ConcreteComponent concreteComponent = new ConcreteComponent();
        //构造装饰者对象A，并调用
        ConcreteDecoratorA concreteDecoratorA = new ConcreteDecoratorA(concreteComponent);
        concreteDecoratorA.operation();
        System.out.println("----");
        //构造装饰者对象B,并调用
        ConcreteDecoratorA concreteDecoratorB = new ConcreteDecoratorA(concreteComponent);
        concreteDecoratorB.operation();
    }
}

为了让大家更好的理解装饰者设计模式，现在有如下场景：

比如我们现在要去买一份炒饭，如果什么都不加的话，只要五元；加青椒的话，多收五元；加肉丝的话多收三元。

• (1)、米饭基类：

public abstract class Rice {
    private String name;

    public String getName() {
        return name;
    }

    public abstract int getPrice();
}

米饭基类里面有一个名称和一个价格：

• (2)、炒饭基类：

public class FryRice extends Rice {
    public FryRice() {
    }

    @Override
    public String getName() {
        return "炒饭";
    }

    @Override
    public int getPrice() {
        return 5;
    }
}

炒饭返回的价格是5元

• (3)、配料类，相当于上面的装饰类

public class Ingredient extends Rice {
    private Rice rice;

    public Ingredient(Rice rice) {
        this.rice = rice;
    }

    @Override
    public String getName() {
        return rice.getName();
    }

    @Override
    public int getPrice() {
        return rice.getPrice();
    }
}

• (4)、火腿配料

public class Ham extends Ingredient {
    public Ham(Rice rice) {
        super(rice);
    }

    @Override
    public String getName() {
        return super.getName() + ",加火腿";
    }

    @Override
    public int getPrice() {
        return super.getPrice() + 3;
    }
}

• (5)、瘦肉配料：

public class Lean extends Ingredient {
    public Lean(Rice rice) {
        super(rice);
    }

    @Override
    public String getName() {
        return super.getName() + ",加瘦肉";
    }

    @Override
    public int getPrice() {
        return super.getPrice() + 4;
    }
}

• (6)、测试类：

public class Client {
    public static void main(String[] args) {
        //炒饭基类
        FryRice fryRice = new FryRice();
        System.out.println(fryRice.getName() + "," + fryRice.getPrice());

        //瘦肉炒饭基类
        Lean leanFryRice = new Lean(fryRice);
        System.out.println(leanFryRice.getName() + "," + leanFryRice.getPrice());

        //瘦肉火腿炒饭
        Ham ham = new Ham(leanFryRice);
        System.out.println(ham.getName() + "," + ham.getPrice());

    }
}

测试结果如下：

    炒饭,5
    炒饭,加瘦肉,9
    炒饭,加瘦肉,加火腿,12

5. 装饰设计模式在Android源码中

在Android中，我们会经常在Activity里面使用startActivity()方法启动一个组件。

startActivity这个方法最开始在Context中定义,Context是一个抽象类，里面定义了许多抽象方法。Context相当于装饰设计模式里面的抽象组件。

startActivity具体实现在ContextImpl中完成的。ContextImpl相当于组件的具体实现。

Activity继承自ContextThemeWrapper,ContextWrapper又继承自Context。

在ContextWrapper里面有如下代码：

Context mBase;
public ContextWrapper(Context base) {
    mBase = base;
}
@Override
public void startActivity(Intent intent) {
    mBase.startActivity(intent);
}

可见这里的ContextWrapper就是我们装饰者。

最后给一下几个类的关系：

6. 总结

• 优点：
  • 装饰模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。继承关系是静态，在系统运行前就决定了；装饰设计模式允许动态决定添加或者删除这些“装饰”。
  • 通过不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合。
• 缺点：
  • 产生多余的类。