装饰器模式

装饰器模式

定义

装饰模式(Decorator Pattern) ：动态地给一个对象增加一些额外的职责(Responsibility)，就增加对象功能来说，装饰模式比生成子类实现更为灵活。其别名也可以称为包装器(Wrapper)，与适配器模式的别名相同，但它们适用于不同的场合。根据翻译的不同，装饰模式也有人称之为“油漆工模式”。
这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

解决

我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。
装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任，换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。装饰模式可以在不需要创造更多子类的情况下，将对象的功能加以扩展。

优点

• 装饰模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。
• 可以通过一种动态的方式来扩展一个对象的功能，通过配置文件可以在运行时选择不同的装饰器，从而实现不同的行为。
• 通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合。可以使用多个具体装饰类来装饰同一对象，得到功能更为强大的对象。
• 具体构件类与具体装饰类可以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类，在使用时再对其进行组合，原有代码无须改变，符合“开闭原则”

缺点

• 使用装饰模式进行系统设计时将产生很多小对象，这些对象的区别在于它们之间相互连接的方式有所不同，而不是它们的类或者属性值有所不同，同时还将产生很多具体装饰类。这些装饰类和小对象的产生将增加系统的复杂度，加大学习与理解的难度。
• 这种比继承更加灵活机动的特性，也同时意味着装饰模式比继承更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为烦琐

结构

装饰模式包含如下角色：

• Component: 抽象构件
• ConcreteComponent: 具体构件
• Decorator: 抽象装饰类
• ConcreteDecorator: 具体装饰类
  

实现

package decoratormethod;

/**
 * Component是定义一个对象接口，给这些对象动态地添加职责
 */
public abstract class Component {
    public abstract void operation();
}

package decoratormethod;
/**
 * ConcreteComponent是定义一个具体对象，可以给这个对象添加一些职责
 */
public class ConcreteComponent extends Component {
    @Override
    public void operation() {
        System.out.println("具体对象的操作");
    }
}

package decoratormethod;

public abstract class Decorator extends Component {
    protected Component component;

//    public Component getComponent() {
//        return component;
//    }

    //设置Component
    public void setComponent(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        if (component != null) {
            component.operation();
        }
    }
}

class ConcreteDecoratorA extends Decorator {
    //ConcreteDecoratorA的独有功能属性
    private String addedState;
    @Override
    public void operation() {
        // 首先运行原Component的operation()，再执行本类的功能，如addedState，相当于对原Component进行了装饰
        super.operation();
        addedState = "A中的new state ";
        System.out.println(addedState + "具体装饰对象A的操作");
    }
}

class ConcreteDecoratorB extends Decorator {
    @Override
    public void operation() {
        super.operation();
        addedBehavior();
        System.out.println("具体装饰对象B的操作");
    }
    //新增方法
    public void addedBehavior() {
        System.out.print("B中的新增行为 ");
    }
}

class ConcreteDecoratorC extends Decorator {
    @Override
    public void operation() {
        super.operation();
        System.out.println("C没有特殊行为 " + "具体装饰对象C的操作");
    }
}

package decoratormethod;
/**
 * 装饰模式客户端，层层包装，用前面的对象装饰后面的对象
 */
public class DecoratorClient {
    public static void main(String[] args) {
        ConcreteComponent cc = new ConcreteComponent();
        ConcreteDecoratorA cda = new ConcreteDecoratorA();
        ConcreteDecoratorB cdb = new ConcreteDecoratorB();
        ConcreteDecoratorC cdc = new ConcreteDecoratorC();

        cda.setComponent(cc);
        cdb.setComponent(cda);
        cdc.setComponent(cdb);
        cdc.operation();
    }
}

实例

人穿衣服，人是Component，衣服是Decorator。当我们只有一个具体的对象时，可以将Component与ConcreteComponent合并为一个类。同样的，当只有一个ConcreteDecorator，可以把Decorator和ConcreteDecorator合并成一个类。那么下面就没有Component类，直接让Decorator继承ConcreteComponent即可。

package decoratormethod.demo;

//Person类(ConcreteComponent)
public class  Person {
    public Person(){}

    private String name;
    public Person(String name)
    {
        this.name=name;
    }
    //在《大话设计模式》中这一个代码是虚函数，java自动实现虚函数
    public void show()
    {
        System.out.println("装扮"+name);
    }
}

package decoratormethod.demo;
//Finery类(Decorator)
public abstract class Finery extends Person {
    protected Person component;

    //打扮
    public void beBeautiful(Person component) {
        this.component = component;
    }
    @Override
    public void show()
    {
        if(component!=null)
        {
            component.show();
        }
    }
}

//下面是具体服饰
class TShirts extends Finery {
    @Override
    public void show() {
        System.out.print("短袖");
        super.show();
    }
}

class BigTrouser extends Finery {
    @Override
    public void show() {
        System.out.print("垮裤");
        super.show();
    }
}

class XZ extends Finery {
    @Override
    public void show() {
        System.out.print("西装");
        super.show();
    }
}

class Tie extends Finery {
    @Override
    public void show() {
        System.out.print("领带");
        super.show();
    }
}

````java
package decoratormethod.demo;
public class DecoratorClient {
    public static void main(String[] args) {
        Person p=new Person("海鸥乙");
        TShirts tShirts=new TShirts();
        BigTrouser bigTrouser =new BigTrouser();

        tShirts.beBeautiful(p);
        bigTrouser.beBeautiful(tShirts);
        bigTrouser.show();

        XZ xz=new XZ();
        Tie tie =new Tie();

        xz.beBeautiful(p);
        tie.beBeautiful(xz);
        tie.show();
    }
}

总结

• 装饰模式用于动态地给一个对象增加一些额外的职责，就增加对象功 能来说，装饰模式比生成子类实现更为灵活。它是一种对象结构型模式。
• 装饰模式包含四个角色：抽象构件定义了对象的接口，可以给这些对 象动态增加职责（方法）；具体构件定义了具体的构件对象，实现了 在抽象构件中声明的方法，装饰器可以给它增加额外的职责（方法）； 抽象装饰类是抽象构件类的子类，用于给具体构件增加职责，但是具体职责在其子类中实现；具体装饰类是抽象装饰类的子类，负责向构 件添加新的职责。
• 使用装饰模式来实现扩展比继承更加灵活，它以对客户透明的方式动态地给一个对象附加更多的责任。装饰模式可以在不需要创造更多子类的情况下，将对象的功能加以扩展。
• 装饰模式的主要优点在于可以提供比继承更多的灵活性，可以通过一种动态的 方式来扩展一个对象的功能，并通过使用不同的具体装饰类以及这些装饰类的 排列组合，可以创造出很多不同行为的组合，而且具体构件类与具体装饰类可 以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类；其主要缺 点在于使用装饰模式进行系统设计时将产生很多小对象，而且装饰模式比继承 更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需 要逐级排查，较为烦琐。
• 装饰模式适用情况包括：在不影响其他对象的情况下，以动态、透明的方式给 单个对象添加职责；需要动态地给一个对象增加功能，这些功能也可以动态地 被撤销；当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展 和维护时。
• 装饰模式可分为透明装饰模式和半透明装饰模式：在透明装饰模式中，要求客 户端完全针对抽象编程，装饰模式的透明性要求客户端程序不应该声明具体构 件类型和具体装饰类型，而应该全部声明为抽象构件类型；半透明装饰模式允 许用户在客户端声明具体装饰者类型的对象，调用在具体装饰者中新增的方法。