深入浅出设计模式——从球赛中悟装饰者模式

一、装饰者模式概念

    装饰者模式是动态地将责任附加到对象上。主要用来动态的给一个对象添加一些额外的功能，同时又不改变它的结构。就为对象增加功能这方面，装饰者模式比使用类的继承更加灵活。在java中，java.io就是用装饰者模式实现的。

    好比足球比赛中，场上的队员有各自的行动（传球，跑位等），这些行动又有一些具体的行为，比如向前向后。那么向前向后就是动态附加到球员行动上的功能，也就是装饰者，用来装饰场上队员的行动。

二、使用场景

    在不想增加子类的情况下动态的为对象添加功能。

三、结构

从上面的UML图中我们可以看出装饰者模式由三个部分组成：

        1. 被装饰者：需要被装饰的对象，这里是场上的球员。

        2. 装饰者的具体实现：实现被装饰者的具体行动，以及一个抽象的装饰者类。

        3. 装饰者：继承抽象装饰者用于装饰被装饰者的具体类。

四、实现

    话不多说，上干货。下面我们就开始使用装饰者模式。

1. 定义被装饰者

/**
 * Description: 被装饰者
 * Designer: jack
 * Date: 2017/8/9
 * Version: 1.0.0
 */
public interface Player {
    //球员的行动
    String action();
}

    被装饰者就是一个简单的接口。这里我是定义了一个球员的接口，他有一个控制他行动的方法。

2. 定义具体行动

（1）球员的具体动作

import cn.jack90john.Player;

/**
 * Description: 球员的传球动作
 * Designer: jack
 * Date: 2017/8/9
 * Version: 1.0.0
 */
public class Pass implements Player {

    private String action;

    public Pass() {
        this.action = "传球";
    }

    @Override
    public String action() {
        return action;
    }
}

    球员具有传球的动作，action方法将传球的动作返回，表示这是一次传球。当然，球员还能有很多的动作，这里就不一一列举出来了，定义和这个都差不多，如有需要可以在文末的源码中查看。

（2）抽象装饰者类

import cn.jack90john.Player;

/**
 * Description: 抽象装饰者类
 * Designer: jack
 * Date: 2017/8/9
 * Version: 1.0.0
 */
public abstract class ActionDecorator implements Player{

    //首先药确定是哪个球员，这里可以不将player设为private，让ActionDecorator的子类直接调用player的方法，
    //但是为了防止player变量在其他地方被串改，作用这里我将它设为private并对外提供一个访问方法。
    private Player player;

    //构造方法，将球员传进来
    ActionDecorator(Player player) {
        this.player = player;
    }

    //重写action方法
    @Override
    public String action(){
        return this.player.action();
    }

}

    抽象装饰者类是所有装饰者类的父类，它的构造方法中接受一个球员类型的参数用于确定是装饰的哪一个球员。同样是靠action方法返回装饰前的球员动作。使用抽象装饰者类的目的很简单，就是要让子类（装饰者）通过重写action()方法来封装Player的子类。

3. 定义装饰者

import cn.jack90john.Player;

/**
 * Description: 装饰者：向前
 * Designer: jack
 * Date: 2017/8/9
 * Version: 1.0.0
 */
public class Forward extends ActionDecorator {
    
    public Forward(Player player) {
        super(player);
    }

    @Override
    public String action() {
        return "向前" + super.action();
    }
    
}

    装饰者继承了抽象装饰者，通过super方法取得抽象装饰者中的球员对象然后对其进行装饰加工并返回经过装饰后的行为。

4. 测试类

import cn.jack90john.action.Dribble;
import cn.jack90john.action.Pass;
import cn.jack90john.action.Running;
import cn.jack90john.decorator.Backward;
import cn.jack90john.decorator.Forward;
import cn.jack90john.decorator.Left;
import cn.jack90john.decorator.Right;

/**
 * Description: 测试类
 * Designer: jack
 * Date: 2017/8/9
 * Version: 1.0.0
 */
public class Test {
    public static void main(String[] args) {

        Player playerA = new Right(new Running());
        System.out.println("球员A：" + playerA.action());

        Player playerB = new Forward(new Pass());
        System.out.println("球员B：" + playerB.action());

        playerA = new Left(new Dribble());
        System.out.println("球员A：" + playerA.action());

        //进球了，球员B开始发疯似的到处乱跑
        playerB = new Forward(new Backward(new Left(new Running())));
        System.out.println("球员B：" + playerB.action());

    }
}

    从测试类中我们可以看到，我们可以用一个或多个装饰者包装一个对象，这是因为装饰者和被装饰对象有相同的超类型，对象在可以任何时候被装饰，所以可以在运行时动态地、不限量地用你喜欢的装饰者来装饰对象。

    执行main方法得到结果：

    可以看出所有的动作都被装饰者装饰，增加了的新的修饰。

五、优点

    1. 装饰者和被装饰者相互独立，互不耦合。

    2. 其动态扩展一个具体类的功能是它可以作为继承的替代者，并且比继承更佳灵活。

六、局限性

    利用装饰者模式，常常造成设计中有大量的小类（装饰者），如果过度使用，会让程序变得很复杂。

    世界上没有十全十美的模式，每个设计模式都有它适用的地方，只要我们的使用方式得当，那么装饰者模式可以帮助我们写出漂亮优雅的代码。

附源码地址：http://git.oschina.net/jack90john/decorator

------------------------------------------------------------------------------

欢迎关注我的个人公众号，推送最新文章

转载于:https://my.oschina.net/jack90john/blog/1511116