这里举一个例子来说明：

有一个女人，她要化妆，这是被装饰者，有一个行为叫化妆；

又有一个女人，她也化妆，不过她先涂粉底，再画眉毛等等一步步下去；

世界上有N多女人，化妆的方式都不一样，如果采用继承，则有N多类，而采用装饰者模式，则简单许多。

女人类

这是被装饰者

public interface Woman {
    public void makeUp();
}

装饰者

public abstract class Decorator implements Woman {
    private Woman woman;

    public Decorator(Woman w) {
        this.woman = w;
    }

    public void makeUp() {
        woman.makeUp();
    }
}

装饰方式1

public class DecoratorWoman1 extends Decorator {

    public DecoratorWoman1(Woman w) {
        super(w);
    }

    @Override
    public void makeUp() {
        super.makeUp();
        fendi();
    }

    // 自定义化妆方式
    public void fendi() {
        System.out.println("打点粉底");
    }
}

装饰方式2

public class DecoratorWoman2 extends Decorator {

    public DecoratorWoman2(Woman w) {
        super(w);
    }

    @Override
    public void makeUp() {
        super.makeUp();
        huamei();
    }

    // 自定义化妆方式
    public void huamei() {
        System.out.println("画下眉毛");
    }
}

装饰方式3

public class DecoratorWoman3 extends Decorator {

    public DecoratorWoman3(Woman w) {
        super(w);
    }

    @Override
    public void makeUp() {
        super.makeUp();
        kouhong();
    }

    // 自定义化妆方式
    public void kouhong() {
        System.out.println("涂点口红");
    }
}

来一个具体的女人

public class XiaoHong implements Woman {

    @Override
    public void makeUp() {
        System.out.println("小红化妆");
    }

}

测试

看小红化妆

public static void main(String[] args) {
        Woman w = new XiaoHong();
//        w.makeUp();
        Decorator dc = new DecoratorWoman1(new DecoratorWoman2(new DecoratorWoman3(w)));
        dc.makeUp();
}

结果：

小红化妆
涂点口红
画下眉毛
打点粉底

应用

现在觉得和什么很像呢？没错，就是IO，那嵌套让人捉摸不定：

try {
    ZipInputStream zin = new ZipInputStream(new BufferedInputStream(new FileInputStream("")));
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

参考文章：http://blog.csdn.net/jason0539/article/details/22713711