装饰模式

一、概述
二、装饰模式的结构
三、具体案列
四、装饰模式与类继承的区别
五、装饰模式的特点：

一、概述

装饰模式又名包装（Wrapper）模式，装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。
装饰模式以对客户端透明的方式动态的给一个对象附加上更多的责任。换言之客户端并不会觉得对象在装饰前和装饰后有什么区别。
装饰模式可以在不创造更多的子类的模式下，将对象的功能加以拓展。

二、装饰模式的结构

　　装饰模式的类图如下：

这里写图片描述

在装饰模式中的角色有：
抽象构件（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 sameOperation(){
        //委派给构件
        component.sampleOperation();
    }
}

三、具体案列

抽象构件角色由Programmer程序员接口扮演
具体构件角色由类Tom扮演他实现了程序员具有的功能
装饰构件由类Derector扮演它必须也实现抽象构件接口
具体装饰构件角色有类Hacker（黑客）和类 SoftwareAchitect(架构师)扮演
具体程序员Tom具有编程能力上帝可以给他赋予更多能力每赋予一种能力，他就多一个技能这是通过装饰构件实现的

//抽象构件角色

/**
 * 抽象构件角色
 *  程序员接口   程序员具有编程的能力
 *
 */
public interface Programmer {
    //编程
    public void programme();
}

//具体构件角色

/**
 * 具体构件角色
 *  汤高是一个具体的程序员
 * 那么他就具有编程能力
 *
 */
public class Tom implements Programmer {
    public void programme() {
        System.out.println("程序员 能编程");
    }
}

//装饰角色

/*
*装饰角色
*/
public class Derector implements Programmer{
    private Programmer programmer;

    public Derector(Programmer programmer){
        this.programmer = programmer;
    }

    @Override
    public void programme(){
        programmer.programme();
        //附加的责任或功能
    }
}

//具体装饰角色1

/**
 * 　具体装饰角色  
 *  黑客类   他具有附加的功能  他能入侵别人的电脑
 */
public class Hacker extends Derector {
    public Hacker(Programmer programmer) {
        super(programmer);
    }

    @Override
    public void programme() {
        super.programme();
        //附加的责任或者功能
        System.out.println("我具有黑客的技能   我能入侵别人的电脑");
    }
}

//具体装饰角色2

/**
 * 　具体装饰角色  
 *  软件架构师类   他具有附加的功能  能设计总个网站或系统的骨
 */
public class SoftwareArchitect extends Derector {
    public SoftwareArchitect(Programmer programmer) {
        super(programmer);
    }
    
    @Override
    public void programme() {
        super.programme();
        //附加的责任或者功能
        System.out.println("我具有架构师的技能  我能设计总个网站或系统的骨架");
    }
}

//客户端

public class Client {
    public static void main(String[] args) {
        //创建构件对象    汤高——》具体的程序员
        //现在要拓展它的功能 对它进行装饰
        Programmer tom = new Tom();
        Derector hacker = new Hacker(tom);
        System.out.println("第一次装饰");
        hacker.programme();

        //我们对它的功能还不满足
        // 进行第二次装饰
        Derector architect = new SoftwareArchitect(hacker);
        System.out.println("第二次装饰");
        architect.programme();


        //也可以一步装饰两个技能 因为他们有共同的父类抽象构件接口 Programmer
        System.out.println("--------------- 一次装饰两个技能");
        Derector softwareArchitect = new SoftwareArchitect(new Hacker(new Tom()));
        softwareArchitect.programme();
    }
}

运行结果：

第一次装饰

程序员能编程
黑客具有黑客的技能
第二次装饰
程序员能编程
黑客具有黑客的技能
安全架构师具有安全架构师的技能
--------------- 一次装饰两个技能
程序员能编程
黑客具有黑客的技能
安全架构师具有安全架构师的技能

四、装饰模式与类继承的区别

1）装饰模式是一种动态行为，对已经存在类进行随意组合，而类的继承是一种静态的行为，一个类定义成什么样的，该类的对象便具有什么样的功能，无法动态的改变。
2）装饰模式扩展的是对象的功能，不需要增加类的数量。而类继承拓展是类的功能，在继承关系中，如果我们想增加一个对象的功能，我们只能通过继承关系，在子类中增加方法。
3）装饰模式是在不改变原类文件和使用继承的情况下，动态的拓展一个对象的功能，它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

五、装饰模式的特点

1）装饰对象和真实对象具有相同的接口，这样客户端对象就可以以真实对象的相同的方式和装饰对象交互。
2）装饰对象包含一个真实对象的引用（reference）
3）装饰对象接收所有来自客户端的请求，它把这些请求转发给真实的对象。
4）装饰对象可以在转发这些请求以前或者以后增加一些附加的功能。
这样就能确保在运行时，不用修改给定对象结构就可以在外部增加附加的功能。
在面向对象的程序设计中，常是使用集成的关系来拓展给定类的功能。

设计模式——装饰模式