装饰器模式

装饰器模式中主要有两个角色：

• 装饰器（夹克，帽子）
• 被装饰的对象（老王）

装饰器和被装饰的对象有两个特点，也是装饰器模式的关键：

• 他们实现同一个接口
• 装饰器中使用了被装饰的对象

使用：

/**
 * <p>
 * 定义一个接口
 * </p>
 *
 * @author aodeng- 低调小熊猫
 * @since 19-7-11
 */
public interface Person {
    /**
     * 计算累计消费
     * @return
     */
    public Double cost();

    /**
     * 输出信息
     */
    public void show();}

/**
 * <p>
 * 老王（被装饰的对象）实现定义的接口
 * </p>
 *
 * @author aodeng- 低调小熊猫
 * @since 19-7-11
 */
public class LaoWang implements Person{
    @Override
    public Double cost() {
        // 没消费，消费为 0
        return 0.0;
    }

    @Override
    public void show() {System.out.println("老王我现在消费"+this.cost());
    }
}

/**
 * <p>
 * 装饰器超类，和被装饰的对象实现同一个接口 Person：* </p>
 *
 * @author aodeng- 低调小熊猫
 * @since 19-7-11
 */
public abstract class ClothesDecorator implements Person{
    /**
     * 装饰器中要使用被装饰器的对象，构造方法中传入
     */
    protected Person person;

    public ClothesDecorator(Person person){this.person=person;}
}

/**
 * <p>
 * 具体的装饰，夹克
 * </p>
 *
 * @author aodeng- 低调小熊猫
 * @since 19-7-11
 */
public class Jacket extends ClothesDecorator{public Jacket(Person person){
        /**
         * super 指向自己超（父）类
         */
        super(person);
    }
    @Override
    public Double cost() {
        // 消费一件夹克
        return person.cost()+100;}

    @Override
    public void show() {person.show();
        System.out.println("老王我现在又消费了一件夹克 100，累计用了"+this.cost());
    }
}

/**
 * <p>
 * 具体的装饰，帽子
 * </p>
 *
 * @author aodeng- 低调小熊猫
 * @since 19-7-11
 */
public class Hat extends ClothesDecorator{public Hat(Person person){
        // 指向自己超（父）类
        super(person);
    }

    @Override
    public Double cost() {return person.cost()+200;
    }

    @Override
    public void show() {person.show();
        System.out.println("老王我现在又消费了一件帽子 200，累计用了"+this.cost());
    }
}

测试

/**
 * <p>
 * 程序入口
 * </p>
 *
 * @author aodeng- 低调小熊猫
 * @since 19-7-11
 */
public class LearnMain {public static void main(String[] args) {
        // 创建一个老王
        Person laoWang=new LaoWang();
        // 老王买了一件夹克
        laoWang=new Jacket(laoWang);
        // 老王买了一个帽子
        laoWang=new Hat(laoWang);
        laoWang.show();
/*
        控制台输出：老王我现在消费 0.0
        老王我现在又消费了一件夹克 100，累计用了 100.0
        老王我现在又消费了一件帽子 200，累计用了 300.0*/
    }
}

源码

源码地址：https://github.com/java-aoden…

本文由低调小熊猫一文多发操作发布！欢迎关注公众号：低调小熊猫

装饰器设计模式的概念

在实际生产中，某个类的行为（它所提供的方法）已经没法满足当前的需要了，但是又需要使用原有的部分功能，因此需要对原有对象进行增强——装饰器设计模式（Decorator Pattern）也叫包装器模式就是为解决此问题而诞生的，它是对原有类的一个包装，属于结构性设计模式。

装饰器模式在不改变现有类方法签名的前提下，对当前的类进行了增强。

Tips

我们使用继承也可以实现，但是会导致类型结构的膨胀，难以维护。

装饰器设计模式的生活场景

我们来看一个现实中的例子，老李头家大儿子去年谈了个朋友，女方要求有车才能领证，所以老李家买了一辆奇瑞 eQ1，但是女方嫌车速太慢喜欢开快车的感觉 … 现在老李家正苦恼中 … 直到有一天在市里工作的大表哥回来听说该情况后，大表哥说这个好整啊，搞到车行去改装一下，把速度提上去就可以了啊。

于是乎，老李家去车行把车进行了改装，车速上去了，媳妇也领到了，皆大欢喜 …

这其实就是一个装饰器的使用案例，原来的 eQ1 车已经没法满足了，所以进行了速度增强，其他功能并没有改变。

装饰器设计模式的特征

• 被增强类、增强类实现同一个接口
• 增强类持有被增强类的引用
• 被增强的方法调用增强类的方法，其他方法保持原有的继续使用被增强类的旧方法

装饰器模式的设计

• 编写一个接口 Car
• 被增强类 QeqCar 实现 Car 接口
• 增强类 Wrapper 实现 Car 接口
• 增强类 Wrapper 持有被增强类 QeqCar 的引用

装饰器设计模式的实现

• Car.java

public interface Car {void run();

    void stop();}

• QeqCar.java

public class QeqCar implements Car {
    @Override
    public void run() {System.out.println("Qeq go...");
    }

    @Override
    public void stop() {System.out.println("Qeq stop!");
    }
}

• WrapperCar.java

public class WrapperCar implements Car {

    private Car car;

    public WrapperCar(Car car) {this.car = car;}

    @Override
    public void run() {System.out.println("wapper run...");
    }

    @Override
    public void stop() {car.stop();
    }
}

• WrapperTest .java

public class WrapperTest {

    @Test
    public void 装饰器模式测试 (){Car car = new WrapperCar(new QeqCar());
        car.run();
        car.stop();}

}

测试输出：

wapper run…
Qeq stop!

更多关于设计模式的资料请参考：JAVA 高级架构师技术栈