【大话设计模式】模式十一：装饰模式以及在IO体系中的应用

【引入】

        当系统需要新功能的时候，是向旧类中添加新的代码。这些新的代码通常装饰了原有的类的核心职责或者主要行为，在主类中加入了新的字段，新的方法和新的逻辑。从而增加了主类的复杂度。相比之下，若要扩展功能，装饰模式提供了比继承更有弹性的替代方案。

一、装饰模式

        装饰模式( Decorator) 是为已有功能动态地添加更多功能的一种方式，给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。[DP]

UML类图： 

• Componet类：定义了一个对象接口，可以给这些对象动态地添加职责。
• ConcreteComponent类：定义了一个具体的对象，也可以给这个对象添加一些职责。
• Decorator类：装饰抽象类，继承了Component类，从外类来扩展Component类的功能，但对于- Component类来说，是无需知道Decorator的存在的。
• ConcreteDecorator类：具体的装饰对象，起到给Component添加职责的功能。实际上会有多个装饰对象。

 【代码实现】

Component类

public abstract class Component {
    public abstract void operation();
}

ConcreteComponent类

public class ConcreteComponent extends Component {
    @Override
    public void operation() {
        System.out.println("具体对象的操作");
    }
}

Decorator类

public class Decorator extends Component {
    private Component component;

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

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

ConcreteDecorator类

public class ConcreteDecoratorA extends Decorator {
    private String state;

    @Override
    public void operation() {
        /**
         * 先运行原来component的operation()，再执行
         * 本类的功能，即相当于对原来Component进行了装饰
         */
        super.operation();
        state = "新状态1";
        System.out.println("具体装饰对象A的操作");
    }
}

public class ConcreteDecoratorB extends Decorator {
    private String state;

    @Override
    public void operation() {
         /**
         * 先运行原来component的operation()，再执行
         * 本类的功能，即相当于对原来Component进行了装饰
         */
        super.operation();
        state = "新状态2";
        System.out.println("具体装饰对象B的操作");
    }
}

 客户端代码

public class Client {
    public static void main(String[] args) {
        ConcreteComponent c=new ConcreteComponent();
        ConcreteDecoratorA A=new ConcreteDecoratorA();
        ConcreteDecoratorB B=new ConcreteDecoratorB();

        /**
         * 先用ConcreteComponent实例化对象C，然后用ConcreteDecoratorA实例化
         * 对象A来包装c,再用ConcreteDecoratorB的对象B来包装A，最后执行B的operation
         */
        A.setComponent(c);
        B.setComponent(A);
        B.operation();

    }
}

二、场景举例

每个人的每一天的穿衣打扮都不一样

UML类图设计

 Person类（ConcreteComponent类）

/**
 *ConcreteComponent类
 */
public class Person {
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public void show(){
        System.out.println("装饰的"+name);
    }
}

服饰类（Decorator）

public class Finery extends Person {
    private Person component;

    //打扮
    public void Decorate(Person person) {
        this.component = person;
    }

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

具体装饰类

//西装
public class Suit extends Finery{
    @Override
    public void show() {
        System.out.print("西装 ");
        super.show();
    }
}
//领带
public class Necktie extends Finery{
    @Override
    public void show() {
        System.out.print("领带 ");
        super.show();
    }
}
//皮鞋
public class LeatherShoes extends Finery{
    @Override
    public void show() {
        System.out.print("皮鞋 ");
        super.show();
    }
}

 客户端类

public class Client {
    public static void main(String[] args) {
        Person person1=new Person("小王");
        System.out.println("第二种打扮:");
        Suit suit=new Suit();
        Necktie necktie=new Necktie();
        LeatherShoes shoes=new LeatherShoes();
        suit.Decorate(person1);
        necktie.Decorate(suit);
        shoes.Decorate(necktie);
        shoes.show();
    }
}

优点 

• 装饰模式利用SetComponent来对对象进行包装。这样每个装饰对象的实现就和如何使用这个对象分离开了，每个装饰对象只关心自己的功能，不需要关心如何被添加到对象链当中[DPE]。
• 当系统需要新功能的时候，如果向旧的类中添加新的代码，这些新加的代码通常装饰了原有类的核心职责或主要行为，但是它们在主类中加入了新的字段，新的方法和新的逻辑，从而增加了主类的复杂度，而这些新加入的东西仅仅是为了满足一些只在某种特定情况下才会执行的特殊行为的需要。
• 而装饰模式却提供了一个非常好的解决方案，它把每个要装饰的功能放在单独的类中，并让这个类包装它所要装饰的对象，因此，当需要执行特殊行为时，客户代码就可以在运行时根据需要有选择地、按顺序地使用装饰功能包装对象了[DP]。
• 把类中的装饰功能从类中搬移去除，这样可以简化原有的类，这样做更大的好处就是有效地把类的核心职责和装饰功能区分开了，而且可以去除相关类中重复的装饰逻辑。

缺点

• 装饰器模式虽然减少了类的爆炸,但是在使用的时候,你就可能需要更多的对象来表示继承关系中的一个对象
• 装饰器模式虽然从数量级上减少了类的数量,但是为了要装饰,仍旧会增加很多的小类这些具体的装饰类的逻辑将不会非常的清晰,不够直观,容易令人迷惑。
• 多层的装饰是比较复杂的。为什么会复杂？你想想看，就像剥洋葱一样，你剥到最后才发现是最里层的装饰出现了问题，可以想象一下工作量。这点从我使用Java I/O的类库就深有感受，我只需要单一结果的流，结果却往往需要创建多个对象，一层套一层，对于初学者来说容易让人迷惑。

 三、装饰模式应用场景实例 

1、IO 体系中的装饰模式，在Java IO中，具体构建角色是节点流、装饰角色是过滤流；

        FilterInputStream和FilterOutputStream是装饰角色，而其他派生自它们的类则是具体装饰角色。DataInputStream input=new DataInputStream(new FileInputStream());

       这就是 装饰者模式,这里不会调用到装饰者类--FilterInputStream,只是作为继承的另一种方案，对客户端来说是透明的，是为了功能的扩张.

2、在JAVA里面的基本数据类型int、boolean、char....都有它们对应的装饰类Integer、Boolean、Character....

---

如果文章对你有用，三连支持一下吧！！！