Java设计模式-装饰模式

定义：

动态的给一个对象添加一些额外的职责。就增加功能来说，装饰模式比生成子类更加灵活。

类图：

抽象构件(Component):是一个接口或者是抽象类，就是定义我们最核心的对象，也就是原始的对象。

具体构件(ConcreteComponent)：是最核心，最原始，最基本的接口或者抽象类的实现，你要装饰的就是它。

装饰角色(Docorator):一般是一个抽象类，做什么用呢？实现接口或者抽象方法，它里面可不一定有抽象方法呀，在它的属性里必然有一个private变量指向Component抽象构件。

具体装饰角色(ConcreteDecoratorA和B):是两个具体的装饰类，你要把你最核心，最原始，最基本的东西装饰成其他东西。

代码：

/*
 * 装饰模式
 */
public class Test {
 
	public static void main(String[] args) {
		//要修饰的对象com
		Component com=new ConcreteComponent();
		
		//进行第一次修饰
		com=new ConcreteDecorator1(com);
		
		//进行第2次修饰
		com=new ConcreteDecorator2(com);
		
		com.operate();
		
		//com=new ConcreteDecorator2(new ConcreteDecorator1(new ConcreteComponent()));
		
 
	}
 
}
 
//抽象构件
abstract class Component{
	//抽象方法
	public abstract void operate();
}
 
//具体构件
class ConcreteComponent extends Component{
 
      //具体实现
	public void operate() {
		System.out.println("这里是具体构件，实现了抽象构件中的方法");
	}
	
}
 
//抽象装饰者，一般为一个抽象类
abstract class Decorator extends Component{
	//必须有一个private变量指向Component抽象构件
	private Component component;
	//通过构造函数传递被修饰者
	public Decorator(Component component)
	{
		System.out.println("这里是抽象类Decortor...");
		this.component=component;
	}
	
	//委托给被修饰者执行
	public void operate()
	{
		System.out.println("父类的操作方法...");
		this.component.operate();
	}
}
 
//具体的装饰类
class ConcreteDecorator1 extends Decorator{
 
	//定义被装饰者
	public ConcreteDecorator1(Component component) {
		super(component);
		
	}
	//定义自己的修饰方法
	private void method1()
	{
		System.out.println("method1修饰。。。");
	}
	
	//重写父类的operate方法
	public void operate()
	{
		this.method1();
		super.operate();
	}
	
}
 
class ConcreteDecorator2 extends Decorator{
 
	//定义被装饰者
	public ConcreteDecorator2(Component component) {
		super(component);
		
	}
	//定义自己的修饰方法
	private void method2()
	{
		System.out.println("method2修饰。。。");
	}
	
	//重写父类的operate方法
	public void operate()
	{
		super.operate();
		this.method2();
	}
	
}