Java设计模式（一）装饰者模式

桃扇骨 2021-09-29 12:18 351阅读 0赞

### 一、基本概念 ###

> 1.定义

装饰（Decorator）模式又叫做包装模式，其功能是动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活，是继承关系的一个替换方案。

装饰模式可以在不创造更多子类的情况下，将对象的功能加以扩展。装饰模式把客户端的调用委派到被装饰类。装饰模式的关键在于这种扩展完全是透明的

装饰模式的应用在 java 的 I/O 流中最为显著。

> 2.适用环境

该模式的适用环境为：

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

（2）处理那些可以撤消的职责。

（3）当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。

> 3.角色

*  *抽象构件角色（Component）*：通常是一个抽象类或者一个接口，定义了一系列方法，方法的实现可以由子类实现或者自己实现。通常不会直接使用该类，而是通过继承该类或者实现该接口来实现特定的功能。
 *  *具体构件角色（Concrete Component）*：是 Component 的子类，实现了对应的方法，它就是那个被装饰的类。
 *  *装饰角色（Decorator）*：是 Component 的子类，它是具体装饰角色共同实现的抽象类（也可以是接口），**并且持有一个 Component 型的对象引用**，它的主要作用就是把客户端的调用委派到被装饰类。
 *  *具体装饰角色（Concrete Decorator）*：它是具体的装饰类，是 Decorator 的子类，当然也是 Component 的子类。它主要就是定义具体的装饰功能

> 4.uml图解

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]

--------------------

### 二、代码实现 ###

被修饰基类——IComponentOutput接口

public interface IComponentOutput { 
        void operator();
    }

--------------------

被修饰子类——Output类

public class Output implements IComponentOutput { 
        @Override
        public void operator() { 
            System.out.println("输出字节流");
        }
    }

--------------------

修饰基类——AbstractBuffer抽象类

public abstract class AbstractBuffer implements IComponentOutput { 
    	//修饰类需要引入被修饰类的基类对象，非常重要！！！
        private IComponentOutput output;
    
        public AbstractBuffer(IComponentOutput output) { 
            this.output = output;
        }
    
        @Override
        public void operator() { 
            output.operator();
        }
    }

--------------------

修饰实现类——Buffer1类

public class Buffer1 extends AbstractBuffer { 
        public Buffer1(IComponentOutput output) { 
            super(output);
        }
    
        @Override
        public void operator() { 
            super.operator();
            this.b1();
        }
    
        void b1() { 
            System.out.println("附加1");
        }
        
    }

--------------------

修饰实现类——Buffer2类

public class Buffer2 extends AbstractBuffer { 
    
        public Buffer2(IComponentOutput output) { 
            super(output);
        }
    
        @Override
        public void operator() { 
            super.operator();
            this.b2();
        }
    
        void b2() { 
            System.out.println("附加2");
        }
    }

--------------------

修饰实现类——Buffer3类

public class Buffer3 extends AbstractBuffer { 
    
        public Buffer3(IComponentOutput output) { 
            super(output);
        }
    
        @Override
        public void operator() { 
            super.operator();
            this.b3();
        }
    
        void b3() { 
            System.out.println("附加3");
        }
    }

有三个修饰子类，用于额外添加不同的附加功能

--------------------

测试类——Client类

public class Client { 
        public static void main(String[] args) { 
    
            IComponentOutput output = new Output();
            output.operator();
    
            System.out.println("===定制1===");
            AbstractBuffer b1 = new Buffer1(output);
            AbstractBuffer b2 = new Buffer2(b1);
            b2.operator();
    
            System.out.println("===定制2===");
            AbstractBuffer b3 = new Buffer3(output);
            b3.operator();
        }
    }
    
    执行结果为：
    输出字节流
    ===定制1===
    输出字节流
    附加1
    附加2
    ===定制2===
    输出字节流
    附加3

--------------------

补充说明：  
注意定制1这种方式：

AbstractBuffer b1 = new Buffer1(output);
    AbstractBuffer b2 = new Buffer2(b1);

第二次的子类的参数是上一个已经修饰过的对象  
这里的方法调用是：

Buffer2.operator()->AbstractBuffer.operator()+b()2
    ->output对象.operator()+b2()->b1.operator()+b2
    
    这里的output对象就起了传递的作用

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]: /images/20210920/376d52cb716446858efabc69ded204d2.png