简易的装饰者模式

简述：在不继承、重构一个类的情况，为这个类定义一个包装的类，修改原类的方法实现。

在装饰模式中的各个角色有（借鉴）：

　　（1）抽象构件（Component）角色：给出一个抽象接口，以规范准备接收附加责任的对象。

　　（2）具体构件（Concrete Component）角色：定义一个将要接收附加责任的类。

　　（3）装饰（Decorator）角色：持有一个构件（Component）对象的实例，并实现一个与抽象构件接口一致的接口。

　　（4）具体装饰（Concrete Decorator）角色：负责给构件对象添加上附加的责任。

定义一个抽象的构建People，定义公共的接口方法eat()：

package demo1;

/**
 * 时间: 2018/3/27.
 *
 * @author zwf
 */
public interface People {
    public abstract void eat();
}

定义具体类的构建Persion，实现接口eat()：

package demo1;

/**
 * 时间: 2018/3/27.
 *
 * @author zwf
 */
public class Person implements People{

    @Override
    public void eat() {
        System.out.println("1个人");
    }
}

定义装饰角色，这边的角色主要的People的定义，一定要定义这个接口类型的对象。这边可以用构造方法实现类对象的赋值，

也可以使用set方法进行赋值。带参数的构造时，子类也需要重写构造方法，测试代码时，可以用new 类（角色）创建，代码简单；这边是使用set方法，更加灵活点。

这边需要定义这个对象，就是装饰者模式对这个类进行装饰，重写了类的方法体实现。代码实现：

package demo1;

/**
 * 时间: 2018/3/27.
 *
 * @author zwf
 */
public abstract class DecoratorAll implements People{
    private People people;

    public DecoratorAll() {
    }

    public DecoratorAll(People people) {
        this.people = people;
    }
    public void setPeople(People people){
        this.people = people;
    }

    @Override
    public void eat() {
        people.eat();
    }
}

义具体的装饰者角色：

package demo1;

/**
 * 时间: 2018/3/27.
 *
 * @author zwf
 */
public class Decorator1 extends DecoratorAll{


    @Override
    public void eat() {
        super.eat();
        System.out.println("吃了中饭");
    }
}

解释super.eat()，个人理解:

调用，则是实现了装饰器对原类eat()方法的扩展。

不调用，则是装饰器对原类方法的重写（不等同继承中的重写）。

测试代码：

package demo1;

/**
 * 时间: 2018/3/27.
 *
 * @author zwf
 */
public class TestMain {
    public static void main(String[] args) {
        Person person = new Person();
        Decorator1 decorator1 = new Decorator1();
        decorator1.setPeople(person);
        decorator1.eat();
    }
}

运行结果：

1个人
吃了中饭

感想：这个装饰者模式在Java的源码IO中很常见，个人实践的也很少，代码写的也不多，只能死记硬背，但是又没有具体在项目中使用到这种模式，很遗憾。