Java结构型设计模式-装饰（二）

装饰

意图

动态给一个对象添加额外的职责，就增加功能来说，装饰（Decorator）模式优于继承。装饰属于对象适配器模式的一种。

别名

包装器Wrapper

动机

当我们希望给某个对象而不是整个类添加功能时，例如，一个图形用户界面工具箱允许你对任何一个用户界面组件增加特性，例如为TextView增加边框。

使用继承机制是添加功能的有效途径，子类可以持续拥有边框的特性。但这种方法不够灵活，用户不能控制对组件加框的方式和时机。

一种较为灵活的方式就是将对象嵌入另一个对象中，由这个对象添加边框，我们称这个嵌入的对象为装饰。

适用性

在以下情景可以使用装饰模式

在不影响其他对象的情况下。

当不便于采用生成子类进行扩充的情形，例如父类的子类已经非常多了，从程序设计的角度不便于扩充。

参与者

Component

• 定义一个对象接口，可以给这些对象动态增加职责。

ConcreteComponent

• 定义一个对象，可以给对象增加职责

Decorator

• 抽象装饰者，继承Component接口，从外类来狂战Componet功能

ConcreteDecorator

• 实现抽象装饰着，向ConcreteComponent对象增加职责，一般构造方法接受ConcreteComponent对象。

实现

例如我们的充电器，有些充电器就降压后的5V电压充电，有些充电器带有过流保护的功能。那么我们假设不带过流保护功能的为ConcreteComponent，带过流保护的为ConcreteDecorator。

Component

public interface Component{    public void Voltage5V();}

ConcreteConponent

public class ConcreteComponent implements Component{    @Override    public void Voltage5V ()    {        System.out.println("输出5V电压");    }}

Decorator

public abstract class Decorator extends ConcreteComponent{    private ConcreteComponent mConcreteComponent;    public Decorator ( ConcreteComponent concreteComponent )    {        mConcreteComponent = concreteComponent;    }    protected abstract void addProtect ();}

ConcreteDecorator

public class ConcreteDecorator extends Decorator{    public ConcreteDecorator ( ConcreteComponent concreteComponent )    {        super(concreteComponent);    }    @Override    protected void addProtect ()    {        super.Voltage5V();        System.out.println("增加过流保护\n");    }}

Test

public class Test{    public static void main(String[] args)    {        ConcreteComponent component = new ConcreteComponent();        ConcreteDecorator decorator = new ConcreteDecorator(component);        decorator.addProtect();     //out add protect.        component.Voltage5V();      //out not protect.    }}

协作

1.得到ConcreteComponet的对象，然后将对象赋入ConcreteDecorator构造器创建对象。

2.ConcreteDecorator对象附加职责。

Android中的Decorator

当我们使用RecyclerView的时候，你可能希望你的RecyclerView有以下功能添加提示无数据的空界面、添加顶部和底部的View、添加下拉监听事件，而因为界面的不同只是需要其中1～3项的功能。这时候装饰模式便派上用场了。下面进行解析。

注：Java类库中的java.io.InputStream、OutputStream、Reader、Writer这些类的所有子类，它们都有一个接受相同类型作为参数的构造函数，返回增加额外方法的子类。

RecyclerView.Adapter相当于Decorator的共同抽象接口。

RecyclerView.Adapter

 public static abstract class Adapter<VH extends ViewHolder>  {       ...... }

EmptyWrapper相当ConcreteDecorator,Decorator的构造器都是同样接受共同抽象接口的实例。

EmptyWrapper

public class EmptyWrapper<T> extends RecyclerView.Adapter<RecyclerView.ViewHolder>{    public static final int ITEM_TYPE_EMPTY = Integer.MAX_VALUE - 1;    private RecyclerView.Adapter mInnerAdapter;    private View mEmptyView;    private int mEmptyLayoutId;    /**     * Receive same abstract class as parameter.      * @param adapter RecyclerView.Adapter     */    public EmptyWrapper(RecyclerView.Adapter adapter)    {        mInnerAdapter = adapter;    }    /**     * Add function.     */    private boolean isEmpty()    {        return (mEmptyView != null || mEmptyLayoutId != 0) && mInnerAdapter.getItemCount() == 0;    }    /**     * Add function.     * @param emptyView view     */      public void setEmptyView(View emptyView)    {        mEmptyView = emptyView;    }    /**     * Add function.     * @param layoutId id     */    public void setEmptyView(int layoutId)    {        mEmptyLayoutId = layoutId;    }    .....}

同理

HeaderAndFooterWrapper

public class HeaderAndFooterWrapper<T> extends RecyclerView.Adapter<RecyclerView.ViewHolder>{    private static final int BASE_ITEM_TYPE_HEADER = 100000;    private static final int BASE_ITEM_TYPE_FOOTER = 200000;    private SparseArrayCompat<View> mHeaderViews = new SparseArrayCompat<>();    private SparseArrayCompat<View> mFootViews = new SparseArrayCompat<>();    private RecyclerView.Adapter mInnerAdapter;    public HeaderAndFooterWrapper(RecyclerView.Adapter adapter)    {        mInnerAdapter = adapter;    }     /**     * add header's View.     * @param view     */    public void addHeaderView(View view)    {        mHeaderViews.put(mHeaderViews.size() + BASE_ITEM_TYPE_HEADER, view);    }    public void addFootView(View view)    {        mFootViews.put(mFootViews.size() + BASE_ITEM_TYPE_FOOTER, view);    }    .......

Test

private void initRecycleView (){        mAdapter = new CommonAdapter< Scenery.ResultBean >(getActivity(), R.layout.item_scenery, mDatas)        {            @Override            protected void convert ( ViewHolder holder, Scenery.ResultBean info, int position )            {                ImageLoader.loadURLImage(getActivity(), info.imgurl, holder.getView(R.id.view_iv_scenery));                holder.setText(R.id.title_tv_scenery, info.title);            }        };        mEmptyWrapper = new EmptyWrapper< Scenery.ResultBean >(mAdapter);        mEmptyWrapper.setEmptyView(LayoutInflater.from(mContext).inflate(R.layout.view_empty, mRecyclerView, false));        mRecyclerView.setAdapter(mEmptyWrapper);}

效果

1.比静态继承更为灵活

与对象的继承相比，Decorator模式提供了更加灵活向对象添加功能的方式，减少了类的复杂程度。

2.避免在层次结构高层的类有太多特征

Decorator模式提供了一种“即用即付”的方式来添加功能，你在设计之前可以不用过多的预见功能，可以使用Decorator逐渐添加功能。遵循了设计的“开闭原则”。

3.不可随意更改Component

因为所有的Decorator都继承了共同的抽象接口Component，如果Component发生变化，会影响所有的Decorator。

4.调试困难

比继承更加灵活机动的特性，也同时意味着装饰模式比继承更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为烦琐，所以只在必要的时候使用装饰者模式。

5.效率影响

装饰链不能过长，否则会影响效率。

源码下载