说明：本文是《大话设计模式》的学习记录及结合网上相关信息编写，原书代码例子采用C#编写，本文采用Java稍加改写。如有不当，欢迎指正，共同进步。
1.装饰模式概述:
装饰模式（Pattern:Decorator）属于结构型模式，指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。
2.装饰模式包含的角色及其职责:
（1）抽象构件角色[Component]：给出一个抽象接口，以规范准备接收附加责任的对象。
（2）具体构件角色[Concrete Component]：定义一个将要接收附加责任的类。
（3）装饰角色[Decorator]：持有一个构件（Component）对象的实例，并实现一个与抽象构件接口一致的接口。
（4）具体装饰角色[Concrete Decorator]：负责给构件对象添加上附加的责任。
3.策略模式的设计原则及UML类图:
（1）设计原则：
① 多用组合，少用继承。
利用继承设计子类的行为，是在编译时静态决定的，而且所有的子类都会继承到相同的行为。然而，如果能够利用组合的做法扩展对象的行为，就可以在运行时动态地进行扩展。
②类应设计的对扩展开放，对修改关闭。
（2）UML类图：
4.Java案例代码:
（1）装饰模式代码简化原则：
①如果只有一个Concrete Component类而没有抽象的Component接口时，可以让Decorator继承Concrete Component。
②如果只有一个Concrete Decorator类时，可以将Decorator和Concrete Decorator合并。
（2）代码结构图：
（3）具体构件角色：
package DecoratorPattern;
/**
* 具体构建角色[ConcreteComponent]
*/
public abstract class Person {
private String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
public abstract void show();
}（4）装饰角色：
package DecoratorPattern;
/**
* 服饰类[Decorator]
*/
public class Finery extends Person {
private Person person;
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
//打扮
public void Decorate(Person person) {
this.person = person;
}
@Override
public void show() {
if (person != null) {
person.show();
}
}
}（5）具体装饰角色：
package DecoratorPattern;
/**
* 具体服饰类[ConcreteDecorator]之‘T恤’
*/
public class TShirts extends Finery {
@Override
public void show() {
System.out.print("T恤 ");// 在实际开发中，此应该为对人数据进行处理的过程。
super.show();// 父类处理的过程
}
}
/**
* 具体服饰类[ConcreteDecorator]之‘垮裤’
*/
class BigTrouser extends Finery{
@Override
public void show() {
System.out.print("垮裤 ");
super.show();
}
}
/**
* 具体服饰类[ConcreteDecorator]之‘破球鞋’
*/
class Sneakers extends Finery{
@Override
public void show() {
System.out.print("破球鞋 ");
super.show();
}
}
/**
* 具体服饰类[ConcreteDecorator]之‘西装’
*/
class Suit extends Finery{
@Override
public void show() {
System.out.print("西装 ");
super.show();
}
}
/**
* 具体服饰类[ConcreteDecorator]之‘领带’
*/
class Tie extends Finery{
@Override
public void show() {
System.out.print("领带 ");
super.show();
}
}
/**
* 具体服饰类[ConcreteDecorator]之‘皮鞋’
*/
class LeatherShoes extends Finery{
@Override
public void show() {
System.out.print("皮鞋 ");
super.show();
}
}（6）客户端测试代码：
package DecoratorPattern;
public class Test {
public static void main(String[] args) {
String name = "小菜";
Person person = new Person(name) {
@Override
public void show() {
System.out.print("装扮的" + name);
}
};
System.out.print("第一种装扮：");
Sneakers sneakers = new Sneakers(); //破球鞋
BigTrouser bigTrouser = new BigTrouser(); //垮裤
TShirts tShirts = new TShirts(); //T恤
sneakers.Decorate(person);
bigTrouser.Decorate(sneakers);
tShirts.Decorate(bigTrouser);
tShirts.show();
//----------------------------------------------------------
System.out.print("\n第二种装扮：");
LeatherShoes leatherShoes = new LeatherShoes(); //皮鞋
Tie tie = new Tie(); //领带
Suit suit = new Suit(); //西装
leatherShoes.Decorate(person);
tie.Decorate(leatherShoes);
suit.Decorate(tie);
suit.show();
}
}（7）客户端测试代码结果：
5.装饰模式的优缺点及使用场景:
（1）优点：
①装饰模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。
②通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合。
（2）缺点：
①这种比继承更加灵活机动的特性，也同时意味着更加多的复杂性。
②装饰模式会导致设计中出现许多小类，如果过度使用，会使程序变得很复杂。
③装饰模式是针对抽象组件（Component）类型编程。但是，如果你要针对具体组件编程时，就应该重新思考你的应用架构，以及装饰者是否合适。当然也可以改变Component接口，增加新的公开的行为，实现“半透明”的装饰者模式。在实际项目中要做出最佳选择。
（3）应用场景：
①需要扩展一个类的功能，或给一个类添加附加职责。
②需要动态的给一个对象添加功能，这些功能可以再动态的撤销。
③需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变的不现实。
④当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。
