装饰者设计模式主要是利用多态，将子类对象作为参数互相传递（主要为了传递实现的函数），达到互相装饰的效果，从而减少代码重复率，优化代码结构。
装饰者模式结构图
一段简单的程序：
/
一家三口每个人都会工作，儿子的工作就是画画，母亲的工作就是在儿子的基础上做一个增强，不单止可以画画，还可以上涂料。
爸爸的工作就是在妈妈基础上做了增强，就是上画框。
/
interface Work{
public void work();
}
class Son implements Work{ //所有装饰类都实现一个统一的接口或者继承同一个父类
@Override
public void work() {
System.out.println("画画...");
}
}
class Mother implements Work{
Work worker; //需要被增强的类内部维护一个需要“继承”的类实例，但不使用继承
public Mother(Work worker){
this.worker = worker;
}
@Override
public void work() {
worker.work(); //调用的哪个work方法？
System.out.println("给画上颜色..");
}
}
class Father implements Work{
//需要被增强的类的引用
Work worker;
public Father(Work worker){
this.worker = worker;
}
@Override
public void work() {
worker.work();
System.out.println("上画框...");
}
}
public class Demo3 {
public static void main(String[] args) {
Son s = new Son();
s.work();
Mother m = new Mather(s); //将Son对象实例作为参数传递进去，从而实现类似“继承”的功能
m.work();
Father f = new Father(m); //将Mother对象实例传入，Father对象实现三个功能
f.work(); //如果将上一行替换成 Father f = new Father(s); 将出现什么样的输出？
}
}
二、装饰者设计模式(Decorator)的相关概念
装饰者模式(Decorator)是一种结构式模式。动态地给一个对象添加一些额外的职责。就增加功能来说，装饰者模式相比生成子类更为灵活。同时还可以让这些装饰类互相装饰。
1.装饰者设计模式的步骤：
a. 在装饰类的内部维护一个被装饰类的引用。
b. 让装饰类有一个共同的父类或者是父接口。
具体过程：
1.Component : 定义一个对象接口，可以给这些对象动态地添加职责。
interface Component {
public void operation();
}
ConcreteComponent : 实现 Component 定义的接口。
class ConcreteComponent implements Component {
@Override
public void operation() {
System.out.println("初始行为");
}
}
2.Decorator : 装饰抽象类，继承了 Component， 从外类来扩展 Component 类的功能，但对于 Component 来说，是无需知道 Decorator 的存在的。
class Decorator implements Component {
// 维护一个 Component 对象，和 Component 形成聚合关系
protected Component component;
// 传入要进一步修饰的对象
public Decorator(Component component) {
this.component = component;
}
@Override
// 调用要修饰对象的原方法
public void operation() {
component.operation();
}
}
3.ConcreteDecorator : 具体的装饰对象，起到给 Component 添加职责的功能。
class ConcreteDecoratorA extends Decorator {
private String addedState = "新属性1";
public ConcreteDecoratorA(Component component) {
super(component);
}
public void operation() {
super.operation();
System.out.println("添加属性: " + addedState);
}
}
class ConcreteDecoratorB extends Decorator {
public ConcreteDecoratorB(Component component) {
super(component);
}
public void operation() {
super.operation();
AddedBehavior();
}
public void AddedBehavior() {
System.out.println("添加行为");
}
}
测试代码
public class DecoratorPattern {
public static void main(String[] args) {
Component component = new ConcreteComponent();
component.operation();
System.out.println("======================================");
Decorator decoratorA = new ConcreteDecoratorA(component);
decoratorA.operation();
System.out.println("======================================");
Decorator decoratorB = new ConcreteDecoratorB(decoratorA);
decoratorB.operation();
}
}
运行结果：
初始行为
======================================
初始行为
添加属性: 新属性1
======================================
初始行为
添加属性: 新属性1
添加行为
2.装饰者设计模式的应用场景
a.需要动态的、透明的为一个对象添加职责，即不影响其他对象。
b.需要动态的给一个对象添加功能，这些功能可以再动态的撤销。
c.需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变的不现实。
d.当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。
3.装饰者设计模式的相关要点：
a.装饰对象和真实对象有相同的接口。这样客户端对象就能以和真实对象相同的方式和装饰对象交互。
b.装饰对象包含一个真实对象的引用（reference）。
c.装饰对象接受所有来自客户端的请求。它把这些请求转发给真实的对象。
d.装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展。
4.继承实现的增强类和修饰模式实现的增强类有何区别？
继承实现的增强类：
优点：代码结构清晰，而且实现简单.
缺点：对于每一个的需要增强的类都要创建具体的子类来帮助其增强，这样会导致继承体系过于庞大。
装饰者设计模式实现的增强类：
优点：内部可以通过多态技术对多个需要增强的类进行增强，可以使这些装饰类达到互相装饰的效果，使用比较灵活。
缺点：需要内部通过多态技术维护需要被增强的类的实例。进而使得代码稍微复杂。
三、装饰者设计模式在IO中的应用
/*
需求1： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有行号。
需求2：编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有分号。
需求3： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有双引号。
需求4： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有行号+ 分号。
*/
import java.io.IOException;
//带行号的缓冲输入字符流
class BufferedLineNum2 extends BufferedReader{
//在内部维护一个被装饰类的引用。
BufferedReader bufferedReader;
int count = 1;
public BufferedLineNum2(BufferedReader bufferedReader){
super(bufferedReader);// 注意： 该语句没有任何的作用，只不过是为了让代码不报错。
this.bufferedReader = bufferedReader;
}
public String readLine() throws IOException{
String line = bufferedReader.readLine();
if(line==null){
return null;
}
line = count+" "+line;
count++;
return line;
}
}
//带分号缓冲输入字符流
class BufferedSemi2 extends BufferedReader{ //为什么要继承? 是为了让这些装饰类的对象可以作为参数进行传递，达到互相装饰 的效果。
//在内部维护一个被装饰类的引用。
BufferedReader bufferedReader;
public BufferedSemi2(BufferedReader bufferedReader){ // new BuffereLineNum();
super(bufferedReader);// 注意： 该语句没有任何的作用，只不过是为了让代码不报错。
this.bufferedReader = bufferedReader;
}
public String readLine() throws IOException{
String line = bufferedReader.readLine(); //如果这里的ReadLine方法是调用了buffereLineNum的readLine方法，问题马上解决。
if(line==null){
return null;
}
line = line +";";
return line;
}
}
//缓冲类带双引号
class BufferedQuto2 extends BufferedReader{
//在内部维护一个被装饰的类
BufferedReader bufferedReader;
public BufferedQuto2(BufferedReader bufferedReader){ //new BufferedSemi2();
super(bufferedReader) ; //只是为了让代码不报错..
this.bufferedReader = bufferedReader;
}
public String readLine() throws IOException{
String line = bufferedReader.readLine(); //如果这里的ReadLine方法是调用了buffereLineNum的readLine方法，问题马上解决。
if(line==null){
return null;
}
line = "\""+line +"\"";
return line;
}
}
public class Demo2 {
public static void main(String[] args) throws IOException {
File file = new File("F:\\Demo1.java");
FileReader fileReader = new FileReader(file);
//建立缓冲输入字符流
BufferedReader bufferedReader = new BufferedReader(fileReader);
//建立带行号的缓冲输入字符流
BufferedLineNum2 bufferedLineNum = new BufferedLineNum2(bufferedReader);
//带分号的缓冲输入字符流
BufferedSemi2 bufferedSemi2 = new BufferedSemi2(bufferedLineNum);
//带双引号的缓冲输入字符流
BufferedQuto2 bufferedQuto2 = new BufferedQuto2(bufferedSemi2);
String line = null;
while((line = bufferedQuto2.readLine())!=null){
System.out.println(line);
}
}
}