设计模式之禅-装饰模式

装饰模式

例子

成绩单。
想要家长给成绩单签字，但是自己考得不怎么样，就得先告诉点好听的。比如说自己的最高分，说自己成绩还是差，但排名提升了。
通过不停的继承来增加装饰，嵌套层数会越来越多。
在面向对象的设计中，如果超过两层继承，就应该想想是不是出设计问题了。

成绩单抽象

public abstract class SchoolReport {
    /**
     * 成绩情况
     */
    public abstract void report();

    /**
     * 家长签字
     * @param name name
     */
    public abstract void sign(String name);
}

成绩单实现

public class FouthGradeSchoolReport extends SchoolReport{
    @Override
    public void report() {
        System.out.println("成绩是：");
        System.out.println("语文：20 数学：25 体育：89 ");
        System.out.println("......");
        System.out.println("家长签字：");
    }

    @Override
    public void sign(String name) {
        System.out.println("家长的名字为："+name);
    }
}

装饰者抽象

public abstract class Decorator extends SchoolReport{

    private final SchoolReport sr;

    public Decorator(SchoolReport sr) {
        this.sr = sr;
    }

    @Override
    public void report(){
        this.sr.report();
    }

    @Override
    public void sign(String name){
        this.sr.sign(name);
    }
}

装饰者实现1

public class HighScoreDecorator extends Decorator {
    public HighScoreDecorator(SchoolReport sr) {
        super(sr);
    }
    private void reportHighScore(){
        System.out.println("这次考试语文最高是75，数学是78，自然是80");
    }
    @Override
    public void report(){
        this.reportHighScore();
        super.report();
    }
}

装饰者实现2

public class SortDecorator extends Decorator {
    public SortDecorator(SchoolReport sr) {
        super(sr);
    }

    private void reportSort() {
        System.out.println("我是排名第38名...");
    }

    @Override
    public void report() {
        super.report();
        this.reportSort();
    }
}

场景类

public class Father {
    public static void main(String[] args) {
        SchoolReport sr = new FouthGradeSchoolReport();
        //加了最高分说明的成绩单
        sr = new HighScoreDecorator(sr);
        //又加了成绩排名的说明
        sr = new SortDecorator(sr);
        sr.report();
        sr.sign("gclhaha");
    }
}

输出

这次考试语文最高是75，数学是78，自然是80
成绩是：
语文：20 数学：25 体育：89 
......
家长签字：
我是排名第38名...
家长的名字为：gclhaha

定义

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

• Component抽象构件
  Component是一个接口或者是抽象类，就是定义我们最核心的对象，也就是最原始的对象，如上面的成绩单。
• ConcreteComponent 具体构件
  ConcreteComponent是最核心、最原始、最基本的接口或抽象类的实现，你要装饰的就是它。
• Decorator装饰角色
  在它的属性里必然有一个private变量指向Component抽象构件。
• 具体装饰角色
  ConcreteDecoratorA和ConcreteDecoratorB是两个具体的装饰类，你要把你最核心的、最原始的、最基本的东西装饰成其他东西，上面的例子就是把一个比较平庸的成绩单装饰成家长认可的成绩单。

public abstract class Component {
    /**
     * 抽象方法
     */
    public abstract void operate();
}

public class ConcreteComponent extends Component{
    @Override
    public void operate() {
        System.out.println("do something");
    }
}

public abstract class Decorator extends Component{
    private Component component = null;

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

    @Override
    public void operate(){
        this.component.operate();
    }
}

public class ConcreteDecorator1 extends Decorator{
    public ConcreteDecorator1(Component component) {
        super(component);
    }
    private void method1(){
        System.out.println("method1 修饰");
    }
    @Override
    public void operate(){
        this.method1();
        super.operate();
    }
}

public class ConcreteDecorator2 extends Decorator{
    public ConcreteDecorator2(Component component) {
        super(component);
    }
    private void method2(){
        System.out.println("method2 修饰");
    }
    @Override
    public void operate(){
        super.operate();
        this.method2();
    }
}

public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        // 第一次装饰
        component = new ConcreteDecorator1(component);
        // 第二次装饰
        component = new ConcreteDecorator2(component);
        // 修饰后运行
        component.operate();
    }
}

输出

method1 修饰
do something
method2 修饰

优点

• 装饰类和被装饰类可以独立发展，而不会相互耦合。换句话说，Component类无须知道Decorator类，Decorator类是从外部来扩展Component类的功能，而Decorator也不用知道具体的构件。
• 装饰模式是继承关系的一个替代方案。我们看装饰类Decorator，不管装饰多少层，返回的对象还是Component，实现的还是is-a的关系。
• 装饰模式可以动态地扩展一个实现类的功能，这不需要多说，装饰模式的定义就是如此。

缺点

多层的装饰是比较复杂的。尽量减少装饰类的数量，以便降低系统的复杂度。

使用场景

• 需要扩展一个类的功能，或给一个类增加附加功能。
• 需要动态地给一个对象增加功能，这些功能可以再动态地撤销。
• 需要为一批的兄弟类进行改装或加装功能，当然是首选装饰模式。

最佳实践

装饰模式是对继承的有力补充。解决我们类膨胀的问题。扩展性非常好。