装饰者模式

设计模式文章

装饰器模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

优点：

装饰者模式比继承灵活性，在不改变原有对象的情况下给对象扩展功能，符合开闭原则。继承关系是静态的，在编译的时候就已经决定了行为，不便于控制增加行为的方式和时机。
装饰者模式可以动态使用不同的装饰类排列组合，创造出多样的行为组合。

缺点：

1.装饰模式会导致设计出大量的ConcreteDecorator类，增加系统的复杂性。
2.对于多次装饰的对象，一旦出现错误，排错繁琐；

装饰模式的结构与实现

通常情况下，扩展一个类的功能会使用继承方式来实现。但继承具有静态特征，耦合度高，并且随着扩展功能的增多，子类会很膨胀。如果使用组合关系来创建一个包装对象（即装饰对象）来包裹真实对象，并在保持真实对象的类结构不变的前提下，为其提供额外的功能，这就是装饰模式的目标。下面来分析其基本结构和实现方法。

1. 模式的结构

装饰模式主要包含以下角色。

抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。
具体构件（Concrete Component）角色：实现抽象构件，通过装饰角色为其添加一些职责。
抽象装饰（Decorator）角色：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
具体装饰（ConcreteDecorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

装饰模式的结构图如图所示。

2. 模式的实现

装饰模式的实现代码如下：

package decorator;
public class DecoratorPattern
{
    public static void main(String[] args)
    {
        Component p=new ConcreteComponent();
        p.operation();
        System.out.println("---------------------------------");
        Component d=new ConcreteDecorator(p);
        d.operation();
    }
}

//抽象构件角色
interface  Component
{
    public void operation();
}

//具体构件角色
class ConcreteComponent implements Component
{
    public ConcreteComponent()
    {
        System.out.println("创建具体构件角色");       
    }   
    public void operation()
    {
        System.out.println("调用具体构件角色的方法operation()");           
    }
}

//抽象装饰角色
class Decorator implements Component
{
    private Component component;   
    public Decorator(Component component)
    {
        this.component=component;
    }   
    public void operation()
    {
        component.operation();
    }
}

//具体装饰角色
class ConcreteDecorator extends Decorator
{
    public ConcreteDecorator(Component component)
    {
        super(component);
    }   
    public void operation()
    {
        super.operation();
        addedFunction();
    }
    public void addedFunction()
    {
        System.out.println("为具体构件角色增加额外的功能addedFunction()");           
    }
}

应用实现

装饰者模式可以给已经存在的对象动态的添加能力。下面，我将会用一个简单的例子来演示一下如何在程序当中使用装饰者模式。

1. 装饰者模式

让我们来假设一下，你正在寻找一个女朋友。有很多来自不同国家的女孩，比如：美国，中国，日本，法国等等，他们每个人都有不一样的个性和兴趣爱好，如果需要在程序当中模拟这么一种情况的话，假设每一个女孩就是一个Java类的话，那么就会有成千上万的类，这样子就会造成类的膨胀，而且这样的设计的可扩展性会比较差。

因为如果我们需要一个新的女孩，就需要创建一个新的 Java 类，这实际上也违背了在程序开发当中需要遵循的OCP（对扩展开放，对修改关闭）原则。让我们来重新做另外一种设计，让每一种个性或者兴趣爱好成为一种装饰从而可以动态地添加到每一个女孩的身上。

2. 类图结构

3.装饰者模式示例代码

// Girl.java
public abstract class Girl {

    String description = "no particular";

    public String getDescription(){
        return description;
    }
}

// AmericanGirl.java
public class AmericanGirl extends Girl {
 
    public AmericanGirl() {
        description = "+American";
    }
}

// EuropeanGirl.java
public class EuropeanGirl extends Girl {
 
    public EuropeanGirl(){
        description = "+European";
    }
}

// GirlDecorator.java
public abstract class GirlDecorator extends Girl {
 
    public abstract String getDescription();

}

// Science.java
public class Science extends GirlDecorator {
 
    private Girl girl;
 
    public Science(Girl girl){
        this.girl = girl;
    }

    @Override
    public String getDescription() {
        return this.girl.getDescription() + "+Like Science";
    }
 
    public void caltulateStuff() {
        System.out.println("scientific calculation!");
    }
}

// Art.java
public class Art extends GirlDecorator {
    private Girl girl;
 
    public Art(Girl girl){
        this.girl = girl;
    }
 
    @Override
    public String getDescription() {
        return this.girl.getDescription() + "+Like Art";
    }

    public void draw() {
        System.out.println("draw pictures!");
    }
}

// Main.java
public class Main {
    public static void main(String[] args) {
        // 普通美国女孩
        Girl g1 = new AmericanGirl();
        System.out.println(g1.getDescription());
        // 喜欢科学的
        Science g2 = new Science(g1);
        System.out.println(g2.getDescription());
        // 喜欢艺术的
        Art g3 = new Art(g2);
        System.out.println(g3.getDescription());
    }
}

应用场景

前面讲解了关于装饰模式的结构与特点，下面介绍其适用的应用场景，装饰模式通常在以下几种情况使用。

当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。例如，该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。
当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，而采用装饰模式却很好实现。
当对象的功能要求可以动态地添加，也可以再动态地撤销时。

装饰模式在 Java 语言中的最著名的应用莫过于 Java I/O 标准库的设计了。例如，InputStream 的子类 FilterInputStream，OutputStream 的子类 FilterOutputStream，Reader 的子类 BufferedReader 以及 FilterReader，还有 Writer 的子类 BufferedWriter、FilterWriter 以及 PrintWriter 等，它们都是抽象装饰类。