装饰者模式

装饰者模式：

 

优点：

1、装饰类和被装饰类可以独立发展，而不会互相耦合。

2、装饰模式是继承关系的一个替代方案

3、装饰模式可以动态地扩展一个实现类的功能

 

缺点： 对于装饰者模式多层的装饰是比较复杂的

 

使用场景：

1、需要扩展一个类的功能，或者给一个类增加附加的功能

2、需要动态地给一个对象增加功能，这些功能可以再动态地撤销

3、需要为一批兄弟类进行改装或加装功能，当然是首选装饰者模式

 

// 抽象构件
abstract class Component {
	// 抽象方法
	public abstract void operate();
}

// 具体构件
class ConcreateComponent extends Component {
	// 具体实现
	@Override
	public void operate() {
		System.out.println("do something");
	}
}

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

	// 通过构造函数传递被修饰者
	public Decorator(Component _component) {
		this.component = _component;
	}

	// 委托给被修饰者执行
	@Override
	public void operate() {
		this.component.operate();
	}
}

/**
 * 具体的装饰类1 原始的方法和装饰方法的执行顺序在具体的装饰类是固定的，可以通过方法的重载实现多种执行顺序。
 * 
 * @author Administrator
 * 
 */
class ConcreateDecorator1 extends Decorator {
	// 定义被修饰者
	public ConcreateDecorator1(Component _component) {
		super(_component);
	}

	// 定义自己的修饰方法
	private void method1() {
		System.out.println("method1 修饰");
	}

	// 重写父类的方法
	@Override
	public void operate() {
		this.method1();
		super.operate();
	}
}

// 具体的装饰类2
class ConcreateDecorator2 extends Decorator {
	// 定义被修饰者
	public ConcreateDecorator2(Component _component) {
		super(_component);
	}

	// 定义自己的修饰方法
	private void method2() {
		System.out.println("method2 修饰");
	}

	// 重写父类的方法
	@Override
	public void operate() {
		this.method2();
		super.operate();
	}
}

public class Main {
	// 场景类
	public static void main(String[] args) {
		Component component = new ConcreateComponent();
		// 第一次修饰
		component = new ConcreateDecorator1(component);
		// 第二次修饰
		component = new ConcreateDecorator2(component);
		// 继续试后运行
		component.operate();
	}

}