装饰模式.

作用

在不改变现有对象结构的前提下动态地给对象增加一些职责（即扩展功能）

架构

抽象角色、具体角色、抽象装饰角色（可以不用）、具体装饰角色

应用场景

1、当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充的时。举个例子，一个类被隐藏或者这个类是终极类（final修饰的类）或者采用继承方式会产生大量的子类（入侵性强）；
2、当需要通过现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，使用装饰模式却很好实现；
3、当对象的功能要求可以动态地添加也可以再动态地撤销时。

代码

用狗狗的一生为例：

==Dog（抽象角色） ==

public interface Dog {

    void eat();
    void play();

}

Grow（具体装饰角色）

public class Grow implements Dog {

    private Dog dog;

    public Grow(Dog dog) {
        this.dog = dog;
    }

    public Grow() {
    }

    /**对方法的增强，不是对类的增强，结构不能改变*/

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

    @Override
    public void play() {
        dog.play();
    }

}

LittleDog（具体角色）

public class LittleDog implements Dog {

    @Override
    public void eat() {
        //增强
        System.out.println("小狗，吃奶");
    }

    @Override
    public void play() {
        //增强
        System.out.println("小狗，学走路");
    }
}

BigDog（具体角色）

public class BigDog extends Grow{

    public BigDog(Dog dog) {
        super(dog);
    }

    @Override
    public void eat() {
        System.out.println("小狗长大了成了大狗，吃肉");
    }

    @Override
    public void play() {
        System.out.println("小狗长大成了大狗，开始拆家了");
    }

    public void weight(){
        System.out.println("小狗长成了大狗，还会保护你");
    }
}

OldDog（具体角色）

public class OldDog extends Grow {

    public OldDog(Dog dog) {
        super(dog);
    }

    @Override
    public void eat() {
        //增强
        System.out.println("大狗老了，吃碎肉");
    }

    @Override
    public void play() {
        //增强
        System.out.println("大狗老了，喜欢睡懒觉");
    }

    //更改了源构件角色的结构
    public void weight(){
        System.out.println("大狗老了，掉了很多毛");
    }
}

DieDog（具体角色）

public class DieDog implements Dog {

    @Override
    public void eat() {
        System.out.println("狗离开了，不用再吃东西了");
    }

    @Override
    public void play() {
        System.out.println("狗离开了，不能陪你玩了");
    }
}

Test

public class Test {

    //狗狗的一生
    public static void main(String[] args) {

        Dog littleDog = new LittleDog();
        littleDog.eat();
        littleDog.play();

        System.out.println("\n");

        Dog bigDog = new BigDog(littleDog);
        bigDog.eat();
        bigDog.play();
        ((BigDog) bigDog).weight();

        System.out.println("\n");

        Dog oldDog = new OldDog(bigDog);
        oldDog.eat();
        oldDog.play();
        ((OldDog) oldDog).weight();

        System.out.println("\n");

        DieDog dieDog = new DieDog();
        dieDog.eat();
        dieDog.play();
    }

}

总结

用来给对象进行方法增强的一个模式，比如原来的对象只能处理一个逻辑，通过装饰模式可以不改变原来对象的结构，来给原来的对象进行添加逻辑、修改逻辑。