设计模式之——装饰器模设计式

如果我想在不必改变原类文件和不使用继承的情况下，动态的扩展一个对象的功能呢？？？

它是通过创建一个包装对象，也就是装饰来包裹真实的对象，进行具体所谓的包装，慢慢的使原有的功能变得更完善和多样。Java中的IO框架就是这个模式（向前辈致敬）。

举个例子，比方说我现在有一套已有的已经实现好的功能：

package com.zndroid.dm.DecoratorModel;

/**
 * Created by luzhenyu on 2017/8/31.
 */

//待装饰的父接口（从另一个角度说是已有的功能）
public interface IComponent {
    void method();
}

package com.zndroid.dm.DecoratorModel;

import com.zndroid.dm.DecoratorModel.IComponent;

/**
 * Created by luzhenyu on 2017/8/31.
 */

//待装饰的父类装饰器（从另一个角度说是已有的功能）
public class ConcreteComponent implements IComponent {
    @Override
    public void method() {
        System.out.println("最原始的方法");
    }
}

那好了，现在我想去扩展原来的功能，因为，随着需求的变化，原来的功能已经不能适应了。

现在我就抽象出这个适配器用于为装饰器定义了我们需要装饰的目标是什么以及基础装饰

package com.zndroid.dm.DecoratorModel;

/**
 * Created by luzhenyu on 2017/8/31.
 */

//抽象出装饰器父类，主要是 为装饰器定义了我们需要装饰的目标是什么以及基础装饰
public abstract class Decorator implements IComponent{

    private IComponent component;
    public Decorator(IComponent component) {
        super();
        this.component = component;
    }

    @Override
    public void method() {
        component.method();//要装饰的行为
    }
}

下面是具体的实现

package com.zndroid.dm.DecoratorModel.impl;

import com.zndroid.dm.DecoratorModel.Decorator;
import com.zndroid.dm.DecoratorModel.IComponent;

/**
 * Created by luzhenyu on 2017/8/31.
 */

//具体的装饰器A
public class ConcreteDecoratorA extends Decorator{

    public ConcreteDecoratorA(IComponent component) {
        super(component);
    }

    //装饰器A新增的方法
    public void methodA() {
        System.out.println("装饰器A新增的方法");
    }

    @Override
    public void method() {
        System.out.println("针对原来的方法进行一层A的包装");
        super.method();
        System.out.println("A包装结束");
    }
}

package com.zndroid.dm.DecoratorModel.impl;

import com.zndroid.dm.DecoratorModel.Decorator;
import com.zndroid.dm.DecoratorModel.IComponent;

/**
 * Created by luzhenyu on 2017/8/31.
 */

//具体的B装饰器
public class ConcreteDecoratorB extends Decorator {

    public ConcreteDecoratorB(IComponent component) {
        super(component);
    }

    //装饰器B新增的方法
    public void methodB() {
        System.out.println("装饰器B新增的方法");
    }

    @Override
    public void method() {
        System.out.println("针对原来的方法进行一层B的包装");
        super.method();
        System.out.println("B包装结束");
    }
}

具体使用：

//原始状态
IComponent component = new ConcreteComponent();
component.method();

//适配器A包装原始的对象ConcreteComponent
ConcreteDecoratorA concreteDecoratorA = new ConcreteDecoratorA(component);
concreteDecoratorA.methodA();//包装A后新增的方法
concreteDecoratorA.method();//A对原始方法的包装

//适配器B包装原始的对象ConcreteComponent
ConcreteDecoratorB concreteDecoratorB = new ConcreteDecoratorB(component);
concreteDecoratorB.methodB();//包装B后新增的方法
concreteDecoratorB.method();//B对原始方法的包装

//用B包装A
ConcreteDecoratorB concreteDecoratorB1 = new ConcreteDecoratorB(concreteDecoratorA);
concreteDecoratorB1.methodB();//A包装B后新增的方法
concreteDecoratorB1.method();//B对A方法的包装
log("----------------我是分割线-----------------");

这样我们就不断滴扩展了已有的功能，而且在原来的结构不变的情况下，棒棒哒~

【欢迎上码】

【微信公众号搜索 h2o2s2】

设计模式之——装饰器模设计式

猜你喜欢