英文名称：（Decorator Pattern）

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

装饰模式的一般模式

Component抽象构件
---|Component是一个接口或者是抽象类，就是定义我们最核心的对象，也就是最原始的对象。
ConcreteComponent具体构件
---|ConcreteComponent是最核心、最原始、最基本的接口或抽象类的实现，要装饰的就是它。
Decorator装饰角色
---|一般是一个抽象类，实现接口或者抽象方法，它的属性里必然有一个private变量指向Component抽象构件
具体装饰角色

---|要把最原始的、最基本的、最核心的东西装饰成其他东西。

public class DecoratorPattern {
	public static void main(String[] args) {
		//拿到原始构件
		Component origin = new ConcreteComponent();
		origin = new ConcreteDecorator1(origin);
		origin = new ConcreteDecorator2(origin);
		origin.doSomething();
	}
}
abstract class Component{
	//抽象的方法，定义一些核心的方法。让子类去实现
	public abstract void doSomething();
}
class ConcreteComponent extends Component{
	
	@Override
	public void doSomething() {
		System.out.println("我是抽象构件的具体实现....");
	}
}
abstract class Decorator extends Component{
	//有一个私有方法，指向Component类
	private Component component;
	
	public Decorator(Component component) {
		this.component = component;
	}
	@Override
	public void doSomething() {
		//让Component的实现类去执行方法。
		this.component.doSomething();
	}
}
/**
 * 1号修饰类
 * @author admin
 *
 */
class ConcreteDecorator1 extends Decorator{
	//指向父类的方法
	public ConcreteDecorator1(Component component) {
		super(component);
	}
	private void decorator1(){
		System.out.println("-----开始之前先修饰-----------");
	}
	@Override
	public void doSomething() {
		System.out.println("-111111111111111111111-");
		//修饰方法
		this.decorator1();
		//执行原始方法
		super.doSomething();
	}
}
/**
 * 2号修饰类
 * @author admin
 *
 */
class ConcreteDecorator2 extends Decorator{
	//指向父类的方法
	public ConcreteDecorator2(Component component) {
		super(component);
	}
	private void decorator2(){
		System.out.println("-----结束之后再修饰-----------");
	}
	@Override
	public void doSomething() {
		System.out.println("-2222222222222222222222-");
		//执行原始方法
		super.doSomething();
		//修饰方法
		this.decorator2();
	}
}

一个例子:

老师把我的成绩单发下来，让家长签字。因为成绩考的不好，所以不能直接把成绩单拿给爸爸看，
因此我得在拿出成绩单前加一些修饰语。例如：告诉爸爸班里同学的最高分，我的分数是多少。
之后再说我在班里的名次。这样就能避免一场海骂了。

public class DecoratorTest {
	public static void main(String[] args) {
		//拿着自己的原始成绩单。
		SchoolScore mScore = new ConcreteStudent();
		//加上一层修饰，最高分的修饰。
		mScore = new HighScoreDecorator(mScore);
		//再加上第二次修饰，我的排名的修饰。
		mScore = new SortDecorator(mScore);
		//做出报告说明
		mScore.report();
		//可以让家长签字了
		mScore.sign("lzl");
	}
}
abstract class SchoolScore{
	//定义一个成绩单的接口，共每个学生去实现
	//每个学生报告给家长，自己的成绩。
	public abstract void report();
	//要求家长签字。
	public abstract void sign(String name);
}
class ConcreteStudent extends SchoolScore{
	@Override
	public void report() {
		System.out.println("我的语文成绩是 89，数学成绩是 78，英语成绩是 77.");
	}

	@Override
	public void sign(String name) {
		System.out.println("家长签字:"+name);
	}
}
/**
 * 因为怕父亲看到成绩被他骂，所以我要来个装饰类。
 * @author admin
 */
abstract class MyDecorator extends SchoolScore{
	//定义学生的成绩
	private SchoolScore score;
	//用构造函数，实例化学生成绩类。
	public MyDecorator(SchoolScore score) {
		this.score = score;
	}
	//抽象方法，为学生提交成绩单时，添加一些修饰方法。
	public void report(){
		this.score.report();
	}
	
	//重写父类的方法。让家长签字
	@Override
	public void sign(String name) {
		this.score.sign(name);
	}
}
/**
 * 首先添加一个全班最高成绩的说明，
 * 让父亲知道我这个成绩还算可以。
 * @author admin
 */
class HighScoreDecorator extends MyDecorator{
	public HighScoreDecorator(SchoolScore score) {
		super(score);
	}
	private void highScoreSchool() {
		System.out.println("语文最高分：99,数学最高分：88，英语最高分：77");
	}
	@Override
	public void report() {
		//先说明最高成绩
		this.highScoreSchool();
		//再报自己的成绩
		super.report();
	}
}
class SortDecorator extends MyDecorator{

	public SortDecorator(SchoolScore score) {
		super(score);
	}
	private void getSort() {
		System.out.println("我在班里的排名是：第十...");
	}
	@Override
	public void report() {
		//先报完成绩
		super.report();
		//再说明名次。
		this.getSort();
	}
}

装饰模式的优点：
---|装饰类和被装饰类可以独立的发展，不会相互耦合。
---|装饰模式是继承关系的一种替代方案。Decorator不管修饰多少层，返回的对象还是Component，实现的还是is-a的关系。
---|装饰模式可以动态的扩展一个实现类的功能。
装饰模式的缺点:
---|多层的装饰模式是比较复杂的。
装饰模式的使用场景：
---|扩展一个类的功能，或给一个类增加附加的功能
---|动态的给一个对象增加功能，这些功能可以动态的撤销
---|为一批的兄弟类进行改装或者加装功能，首选装饰模式。