设计模式解密（9）- 装饰者模式

最新推荐文章于 2025-04-07 15:12:24 发布

原创最新推荐文章于 2025-04-07 15:12:24 发布 · 274 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #装饰者模式

设计模式同时被 2 个专栏收录

28 篇文章

订阅专栏

《设计模式解密》

28 篇文章

订阅专栏

本文详细介绍了装饰模式的概念、特点、应用场景及与其他模式的区别。通过实例演示了装饰模式如何动态地扩展对象的功能，避免类的过度膨胀。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、简介

定义：装饰模式是在不必改变原类文件和使用继承的情况下，动态的扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

拆分定义，总结特点：

　　　　 1、不改变原类文件。

2、不使用继承。

3、动态扩展。

主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

何时使用：在不想增加很多子类的情况下扩展类。

如何解决：将具体功能职责划分，同时继承装饰者模式。

英文：Decrator

类型：结构型模式

2、类图及组成

（引）类图：

角色：

　　●抽象构件(Component)角色：给出一个抽象接口，以规范准备接收附加责任的对象。
　　●具体构件(ConcreteComponent)角色：定义一个将要接收附加责任的类。
　　●装饰(Decorator)角色：持有一个构件(Component)对象的实例，并定义一个与抽象构件接口一致的接口。
　　●具体装饰(ConcreteDecorator)角色：负责给构件对象“贴上”附加的责任。

代码结构：

抽象构件角色
public interface Component {

    public void sampleOperation();

}

具体构件角色
public class ConcreteComponent implements Component {

    @Override
    public void sampleOperation() {
        // 写相关的业务代码    
    }

}

装饰角色
public class Decorator implements Component{
    private Component component;

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

    @Override
    public void sampleOperation() {
        // 委派给构件        
        component.sampleOperation();
    }

}

具体装饰角色
public class ConcreteDecoratorA extends Decorator {

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

    @Override
    public void sampleOperation() {
　　　　  super.sampleOperation();
        // 写相关的业务代码   
    }
}

具体装饰角色
public class ConcreteDecoratorB extends Decorator {

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

    @Override
    public void sampleOperation() {
　　　　  super.sampleOperation();
        // 写相关的业务代码    
    }
}

3、实例引入

本例中抽象构建角色由Coder程序员接口扮演

具体构件角色由类SpecificCoder扮演

装饰构件由类Derector扮演，它必须也实现抽象构件接口

具体装饰构件角色由类JavaCoder(程序员)和类 JavaArchitect(架构师)扮演

具体程序员xxx有编程能力,通过学习和实践,他渐渐的获得很多种能力，每多一种能力，都通过装饰类实现的

package com.designpattern.Decorator;
/**
 * 抽象构建角色
 * 程序员接口
 * @author Json
*/
public interface Coder {

    /**
     * 写代码
     */
    public void writeCode();
}

具体构建角色：

package com.designpattern.Decorator;
/**
 * 具体构建角色
 * 一个具体的程序员
 * @author Json
*/
public class SpecificCoder implements Coder {
    @Override
    public void writeCode() {
        System.out.println("我是一个程序员,我能写代码...");
    }
}

一个具体的装饰角色：

package com.designpattern.Decorator;
/**
 * 一个具体的装饰角色
 * java普通程序员
 * @author Json
*/
public class JavaCoder extends Decorator {
    
    public JavaCoder(Coder coder) {
        super(coder);
    }

    @Override
    public void writeCode(){
        super.writeCode();
        //可以追加功能
        System.out.println("我是Java程序员...");
    }
}

一个具体的装饰角色：

package com.designpattern.Decorator;
/**
 * 一个具体的装饰角色
 * java架构师
 * @author Json
*/
public class JavaArchitect extends Decorator {
    
    public JavaArchitect(Coder coder) {
        super(coder);
    }

    @Override
    public void writeCode(){
        super.writeCode();
        //可以追加功能
        System.out.println("我是Java架构师...");
    }
}

测试：

package com.designpattern.Decorator;
/**
 * 测试
 * @author Json
*/
public class Test {
    public static void main(String[] args) {
        Coder coder = new SpecificCoder();
        
        System.out.println("第一次装饰 ↓↓↓");
        Decorator javacoder = new JavaCoder(coder);
        javacoder.writeCode();
        
        System.out.println("第二次装饰 ↓↓↓");
        Decorator javaarchitect = new JavaArchitect(javacoder);
        javaarchitect.writeCode();
        
        
        System.out.println("------------------------------------");
        System.out.println("一步装饰多次 ↓↓↓");
        //一步装饰多次
        Decorator javaarchitect_1 = new JavaArchitect(new JavaCoder(new SpecificCoder())); 
        javaarchitect_1.writeCode();
    }
}

结果：

第一次装饰 ↓↓↓
我是一个程序员,我能写代码...
我是Java程序员...
第二次装饰 ↓↓↓
我是一个程序员,我能写代码...
我是Java程序员...
我是Java架构师...
------------------------------------
一步装饰多次 ↓↓↓
我是一个程序员,我能写代码...
我是Java程序员...
我是Java架构师...

4、优缺点

优点：

　　1、对于扩展一个对象的功能，装饰模式比继承更加灵活性，不会导致类的个数急剧增加。

　　2、可以通过一种动态的方式来扩展一个对象的功能，通过配置文件可以在运行时选择不同的具体装饰类，从而实现不同的行为。

　　3、可以对一个对象进行多次装饰，通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合，得到功能更为强大的对象。

　　4、具体构件类与具体装饰类可以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类，原有类库代码无须改变，符合“开闭原则”。

缺点：

　　1、使用装饰模式进行系统设计时将产生很多小对象，这些对象的区别在于它们之间相互连接的方式有所不同，而不是它们的类或者属性值有所不同，大量小对象的产生势必会占用更多的系统资源，在一定程序上影响程序的性能。

　　2、装饰模式提供了一种比继承更加灵活机动的解决方案，但同时也意味着比继承更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为繁琐。

5、应用场景

1、在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

2、当不能采用继承的方式对系统进行扩展或者采用继承不利于系统扩展和维护时可以使用装饰模式。不能采用继承的情况主要有两类：第一类是系统中存在大量独立的扩展，为支持每一种扩展或者扩展之间的组合将产生大量的子类，使得子类数目呈爆炸性增长；第二类是因为类已定义为不能被继承（如 Java 语言中的 final 类）。