<Java 设计模式 > 装饰模式(Decorator)-

装饰模式：　　　　　　九十三-20:00

　　装饰模式又名包装（Wrapper）模式；

　　☆ 装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案（继承是扩展类的功能）；

　　☆ 装饰模式以对客户端透明的方式动态的给一个对象附加上更多的职责（而继承是静态的方式）。换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同；

　　装饰模式可以在不创造更多子类的情况下，将对象的功能加以扩展。

　　

　　装饰模式把客户端的调用委派到被装饰类。装饰模式的关键在于这种扩展是完全透明的。

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

 

装饰模式的构成：　　　　九十三-24:00

　　1、抽象构件角色（Component）：给出一个抽象接口，以规范准备接收附加责任的对象；(例如:InputStream)

　　2、具体构件角色（Concrete Component）：定义一个将要接收附加责任的类；(例如:FileInputStream)

　　3、装饰角色（Decorator）：持有一个构件（Component）对象的引用，并实现了一个与抽象构件接口一致的接口；(例如：FilterOutputStream抽象类(所有过滤流类的超类))

　　4、具体装饰角色（Concrete Decorator）：负责给构件对象“贴上”附加的责任。(例如：FilterOutputStream的各个子类)

 

装饰模式的特点：　　　　九十三-27:31

　　装饰对象和真实对象有相同的接口。这样客户端对象就可以以和真实对象相同的方式和装饰对象交互；

　　装饰对象包含一个真实对象的引用（reference）（聚合包容关系）；

　　装饰对象接收所有来自客户端的请求。它把这些请求装法给真实对象；

　　装饰对象可以在转发这些请求之前或之后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加功能。而在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展；

　　

---

 

装饰模式 VS 继承

　　装饰模式：

　　　　1、用来扩展特定对象的功能；

　　　　2、不需要子类；

　　　　3、动态；

　　　　4、运行时分配职责；

　　　　5、防止由于子类而导致的复杂和混乱；

　　　　6、更多的灵活性；

　　　　7、对于一个给定的对象，同时可能有不同的装饰对象，客户端可以通过它的需要选择合适的装饰对象发送消息；

　　继承：

　　　　1、用来扩展一类对象的功能；

　　　　2、需要子类；

　　　　3、静态；

　　　　4、编译时分派职责；

　　　　5、导致很多子类的产生；

　　　　6、缺乏灵活性；

---

 

具体实现如下:

　　Component.java (抽象构件角色)

package en.edu.bupt.decorator;

/**
 * 抽象构建类,制定规范
 * @author Medow
 *
 */
public interface Component
{
    void doSomething();
}

 

　　ConcreteComponent.java　　(具体构件角色)

package en.edu.bupt.decorator;

/**
 * 具体的构件类,完成具体的功能,类比FileInputStream和FileOutputStream
 * @author Medow
 *
 */
public class ConcreteComponent implements Component
{
    @Override
    public void doSomething()
    {
        System.out.println("完成功能A");
    }

}

　　Decorator.java　　(装饰角色)

package en.edu.bupt.decorator;

/**
 * 用于创建装饰角色,是所有具体装饰角色的基类,类比FilterOutputStream 和 FilterInputStream的功能
 * 它持有一个构件角色对象的引用, 并实现了抽象构件角色对应的接口
 * @author Medow
 *
 */
public class Decorator implements Component
{
    private Component component;    // 持有构建角色对象的引用
    
    public Decorator(Component component)
    {
        this.component = component;
    }
    
    /**
     * 完成抽象构件角色中的功能
     */
    @Override
    public void doSomething()
    {
        this.component.doSomething();
    }

}

　　ConcreteDecorator1.java　　　(具体装饰角色)

package en.edu.bupt.decorator;

/**
 * 具体装饰角色,执行构件角色的相关功能,并在执行功能的过程中附加当前装饰类的责任
 * @author Medow
 *
 */
public class ConcreteDecorator1 extends Decorator
{
    public ConcreteDecorator1(Component component)
    {
        super(component);
    }
    
    @Override
    public void doSomething()
    {
        // 首先完成具体组件类中原有的方法
        super.doSomething();
        
        // 具体装饰类中新增的功能
        this.doAnotherThing();
    }
    
    private void doAnotherThing()
    {
        System.out.println("ConcreteDecorator1中新增的功能");
    }
}

　　ConcreteDecorator2.java　　　　(具体装饰角色)

package en.edu.bupt.decorator;

/**
 * 具体装饰角色,执行构件角色的相关功能,并在执行功能的过程中附加当前装饰类的责任
 * @author Medow
 *
 */
public class ConcreteDecorator2 extends Decorator
{
    public ConcreteDecorator2(Component component)
    {
        super(component);
    }
    
    @Override
    public void doSomething()
    {
        // 首先完成具体组件类中原有的方法
        super.doSomething();
        
        // 具体装饰类中新增的功能
        this.doAnotherThing();
    }
    
    private void doAnotherThing()
    {
        System.out.println("ConcreteDecorator2中新增的功能");
    }
}

 

　　Client.java  (测试使用)

package en.edu.bupt.decorator;

public class Client
{
    public static void main(String[] args)
    {
        Component component = new ConcreteComponent();        // 构件具体的构件对象,类似于节点流InputStream和FileInputStream
        
        ConcreteDecorator1 cd1 = new ConcreteDecorator1(component);        // ConcreteDecorator1对象cd1包装ConcreteComponent对象
        ConcreteDecorator2 cd2 = new ConcreteDecorator2(cd1);            // ConcreteDecorator2对象cd2包装cd1对象
        
        cd2.doSomething();
    }
}

 运行结果如下：

 

细节讲解：九十四-03:00

组合(类比IO):

 

运行结果!~