/**
 * 抽象构件
 */
public abstract class Component {
   public abstract void operate();
}
/**
 * 具体构件
 */
public class CreateComponent extends Component {

	@Override
	public void operate() {
		System.out.println("do somthing...........");
	}

}
/**
 * 抽象装饰者
 */
public abstract class Decorator extends Component {
	private  Component component=null;

	public Decorator(Component _component) {
		this.component = _component;
	}

	@Override
	public void operate() {
		this.component.operate();
	}

}
/**
 *2014-10-4上午09:26:44
 */
public class CreateDecorator extends Decorator {

	public CreateDecorator(Component _component) {
		super(_component);
	}
	
	private void method(){
		System.out.println("装饰者1。。。。。");
	}
	
	public void operate() {
		this.method();
		super.operate();
	}
}
public class CreateDecorator2 extends Decorator {

	public CreateDecorator2(Component _component) {
		super(_component);
	}
	private void method(){
		System.out.println("装饰者2。。。。。");
	}
	
	public void operate() {
		this.method();
		super.operate();
	}
	
}
/**
 * 
 *
 *@date  2014-10-4上午09:32:08
 */
public class Client {
	/**
	 * 1.装饰类和被装饰类可以独立发展，不会相互耦合。
	 * 2.装饰模式是一种继承关系的替代方案
	 * 3.装饰模式可以动态的扩展一个实现类的功能。
	 *   装饰模式缺点：
	 *   多层的装饰是比较复杂的
	 *   装饰模式的应用场景：
	 *   1.需要扩展一个类的功能，或者给一个类增加附加的功能
	 *   2.需要动态的给一个对象增加功能，这些功能也可以动态的撤销
	 *   3.需要为一批兄弟类进行改装或增加功能，首选装饰模式
	 */

	public static void main(String[] args) {
		Component component = new CreateComponent();
		
		component = new CreateDecorator(component);
		
		component = new CreateDecorator2(component);
		
		component.operate();
	}

}

装饰者模式