Java设计模式之装饰器模式(Decorator)
1. 简单介绍装饰器模式
装饰模式，动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。（引自《大话设计模式》）
装饰器模式的结构图如下：
逐一介绍一下
Component：对象接口，也可以是一个抽象类，是被装饰类和装饰类的基本类型，可以给这些对象动态地添加职责。
ConcreteComponent：被装饰类，Component的实现类，是要被进行修饰的对象，也可以给这个对象动态地添加职责。可以有多个。
Decorator：装饰类，是一个抽象类，实现了Component，同时，在内部维护了一个ConcreteComponent的实例，可以通过构造函数进行初始化。在其内部只是声明了一个个装饰的方法，具体实现由其子类去实现。
ConcreteDecoratorA/ConcreteDecoratorB：具体的装饰产品类，继承了Decorator，其中可以通过构造器声明装饰哪种类型的ConcreteComponent。还包括装饰的具体实现方法，起到了给Component添加职责的功能。
具体的代码
Component
package main.mode.zsms;
/**
* 定义一个对象接口，是被装饰类和装饰类的基本类型，可以给这些对象动态添加职责。
*/
public interface Component {
public void Operation();
}
ConcreteComponent
package main.mode.zsms;
/**
* 定义了一个具体的对象，是被装饰类，也可以给这个对象添加一些职责。
*/
public class ConcreteComponent implements Component{
@Override
public void Operation() {
System.out.println("This is ConcreteComponent");
}
}
Decorator
package main.mode.zsms;
/**
* 装饰抽象类，实现了Component，从外类来扩展Component类的功能，
* 但对于Component来说，是无需知道Decorator存在的。
*/
public abstract class Decorator implements Component{
Component component = null;
//构造函数，引入component对象
public Decorator(Component component) {
this.component = component;
}
/**
* 重写Operation方法
*/
@Override
public void Operation() {
System.out.println("This is Decorator");
if(component != null) {
component.Operation();
}
}
}
ConcreteDecoratorA
package main.mode.zsms;
/**
* 具体的装饰产品类，起到给Component添加职责的功能
*/
public class ConcreteDecoratorA extends Decorator{
//本类的独有属性，区别于ConcreteDecoratorB
private String addedState;
public ConcreteDecoratorA(Component component) {
super(component);
}
@Override
public void Operation() {
System.out.println("This is ConcreteDecoratorA");
component.Operation();
addedState = "装饰了A";
System.out.println(addedState);
}
}
ConcreteDecoratorB
package main.mode.zsms;
/**
* 具体的装饰产品类，起到给Component添加职责的功能
*/
public class ConcreteDecoratorB extends Decorator{
public ConcreteDecoratorB(Component component) {
super(component);
}
@Override
public void Operation() {
System.out.println("This is ConcreteDecoratorB");
component.Operation();
AddedBehavior();
}
private void AddedBehavior() {
System.out.println("装饰了B");
}
}
测试类
package main.mode.zsms;
public class DecoratorTest {
public static void main(String[] args) {
Component component = new ConcreteComponent();
component.Operation();
System.out.println("---------华丽丽的分割线---------");
Component component1 = new ConcreteDecoratorA(new ConcreteComponent());
component1.Operation();
System.out.println("---------华丽丽的分割线---------");
Component component2 = new ConcreteDecoratorB(new ConcreteComponent());
component2.Operation();
}
}
结果
从测试类可以看出，我分了三部分测试
第一部分是没有进行装饰下的情况；
第二、三部分是有装饰的情况。
2. 举例说明装饰器模式
下面举个例子说明一下：
做一个下午茶的订单系统，通常有奶茶（MilkTea）、柠檬茶（LemonTea）等，可以加糖（Sugar）、冰（Ice）等调料，计算花费。
简单分析：
奶茶和柠檬茶可以有一个共同的父类--饮料（Drink），糖和冰可以有一个共同的父类--调料（Condiment）。MilkTea和LemonTea就是被装饰类，相当于装饰器模式中的ConcreteComponent；Condiment为抽象装饰类，相当于装饰器模式中的Decorator；Sugar和Ice为装饰的具体产品类，相当于装饰器模式中的ConcreteDecorator。
下面上类图
然后上代码
Drink
package main.mode.zsms2;
public abstract class Drink {
//描述
protected String desc;
public String getDesc() {
return desc;
}
//花费
public abstract double cost();
}
MilkTea
package main.mode.zsms2;
public class MilkTea extends Drink{
public MilkTea() {
desc = "奶茶";
}
@Override
public double cost() {
return 12;
}
}
LemonTea
package main.mode.zsms2;
public class LemonTea extends Drink{
public LemonTea() {
desc = "柠檬茶";
}
@Override
public double cost() {
return 10;
}
}
Condiment
package main.mode.zsms2;
public abstract class Condiment extends Drink{
@Override
public abstract String getDesc();
}
Sugar
package main.mode.zsms2;
public class Sugar extends Condiment{
private Drink drink;
public Sugar(Drink drink) {
this.drink = drink;
}
@Override
public String getDesc() {
return drink.getDesc() + "+" + "糖";
}
@Override
public double cost() {
return 0.5+drink.cost();
}
}
Ice
package main.mode.zsms2;
public class Ice extends Condiment{
private Drink drink;
public Ice(Drink drink) {
this.drink = drink;
}
@Override
public String getDesc() {
return drink.getDesc() + "+" + "冰";
}
@Override
public double cost() {
return 0.4+drink.cost();
}
}
测试类
package main.mode.zsms2;
public class DecoratorTest {
public static void main(String[] args) {
Drink milkTea = new MilkTea();
double cost = milkTea.cost();
System.out.println(milkTea.getDesc()+":"+cost+"元");
System.out.println("----------华丽丽的分割线----------");
//奶茶加糖加冰
Drink milkTea2 = new MilkTea();
milkTea2 = new Ice(new Sugar(milkTea2));
double cost2 = milkTea2.cost();
System.out.println(milkTea2.getDesc()+":"+cost2+"元");
System.out.println("----------华丽丽的分割线----------");
//柠檬茶加两份冰
Drink lemonTea = new LemonTea();
lemonTea = new Ice(new Ice(lemonTea));
double cost3 = lemonTea.cost();
System.out.println(lemonTea.getDesc()+":"+cost3+"元");
}
}
测试结果
从测试类中，可以很清楚地看到“装饰”的含义了，什么都不装饰，那就是单纯的new MilkTea()，如果需要装饰就在外面带一个装饰品，就是new Sugar(new MilkTea())，再多带一个装饰品就是new Ice(new Sugar(new MilkTea()))。这就是装饰的含义了吧。
3. 总结
核心就是装饰。
优点：就是可以有效地把类的核心职责和装饰功能区分开了，而且可以去除相关类中重复的装饰逻辑。
需要注意的是：装饰的顺序。并尽量让装饰产品类彼此独立。
说在后面：
本文主要是小猫看《大话设计模式》的笔记式的记录，方便以后查阅。
当然了，我也阅读了许多其它博友相关的博文，再加之自己的理解整理出本文，仅供参考。