转载Java设计模式之装饰Decorator模式

原文地址：https://blog.csdn.net/zaoan_2010/article/details/83308891

简单介绍装饰器模式

装饰模式，动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。（引自《大话设计模式》）

装饰器模式的结构图如下：

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()))。这就是装饰的含义了吧。

总结

核心就是装饰。优点：就是可以有效地把类的核心职责和装饰功能区分开了，而且可以去除相关类中重复的装饰逻辑。需要注意的是：装饰的顺序。并尽量让装饰产品类彼此独立。