关于设计模式:设计模式之装饰器模式

装璜器模式次要解决继承关系过于简单的问题，通过组合来代替继承。它次要的作用是给原始类增加加强性能。

装璜器模式有一个特点，那就是能够对原始类嵌套应用多个装璜器。为了满足这个利用场景，在设计的时候，装璜器类须要跟原始类继承雷同的抽象类或者接口。

Java IO 类库十分宏大和简单，有几十个类，负责 IO 数据的读取和写入。咱们能够把 IO 类分为四类。

	字节流	字符流
输出流	InputStream	Reader
输入流	OutputStream	Writer

针对不同的读取和写入场景，Java IO 又在这四个父类根底之上，扩大出了很多子类。

置信大多数开发者在首次接触 Java IO 类时面对宏大的 Java IO 类家族产生困惑：为什么会有如此多的类？他们应用上有啥区别？

这里以读取 config.properties 文件为例，InputStream 是一个抽象类，FileInputStream 是专门用来读取文件流的子类。BufferedInputStream 是一个反对带缓存性能的数据读取类，能够进步数据读取的效率。

InputStream in = new FileInputStream("config.properties");
InputStream bin = new BufferedInputStream(in);
byte[] data = new byte[128];
while (bin.read(data) != -1) {//...}

Java IO 为什么不设计一个继承 FileInputStream 并且反对缓存的BufferedFileInputStream 类呢？这样咱们就能够间接创立new BufferedFileInputStream() 简略许多。

事实上如果只是扩大这一个类，那还能够承受，然而 InputStream 具备很多子类，如果咱们持续依照继承的形式来实现的话，就须要再持续派生出 DataFileInputStream、DataPipedInputStream 等类。如果咱们还须要既反对缓存、又反对依照根本类型读取数据的类，那就要再持续派生出 BufferedDataFileInputStream、BufferedDataPipedInputStream 等 n 多类。这还只是附加了两个加强性能，如果咱们须要附加更多的加强性能，那就会导致组合爆炸，类继承构造变得无比简单，代码既不好扩大，也不好保护。

所以 Java 的设计者没有应用继承的形式来进行扩大，而是应用组合，这里也体现了组合优于继承的设计准则。上面是简化的 JDK 源码

public abstract class InputStream {// ...}

public class BufferedInputStream extends InputStream {
      protected volatile InputStream in;
    
    public BufferedInputStream(InputStream in) {this.in = in;}
    
        // 实现基于缓存的读取...

}

public class DataInputStream extends InputStream {
      protected volatile InputStream in;
    
    public BufferedInputStream(InputStream in) {this.in = in;}
    
        // 实现读取根本数据类型...

}

如果去查看 JDK 的源码，你会发现，BufferedInputStream、DataInputStream 并非继承自 InputStream，而是另外一个叫 FilterInputStream 的类。

这是因为 InputStream 是一个抽象类，其中很多办法曾经有了默认实现。咱们想复用这些实现，然而咱们是通过在构造函数注入 InputStream，而后赋值给成员变量 InputStream in，将所有性能委托给成员变量in 来实现的，因而抽象类 InputStream 的办法即便被继承，调用的对象也是以后类实例，而不是委托给in，所以须要有一个装璜器类FilterInputStream。

public class FilterInputStream extends InputStream {
  protected volatile InputStream in;
  protected FilterInputStream(InputStream in) {this.in = in;}
  public int read() throws IOException {return in.read();
  }
  public int read(byte b[]) throws IOException {return read(b, 0, b.length);
  }
   
  public int read(byte b[], int off, int len) throws IOException {return in.read(b, off, len);
  }
  public long skip(long n) throws IOException {return in.skip(n);
  }
  public int available() throws IOException {return in.available();
  }
  public void close() throws IOException {in.close();
  }
  public synchronized void mark(int readlimit) {in.mark(readlimit);
  }
  public synchronized void reset() throws IOException {in.reset();
  }
  public boolean markSupported() {return in.markSupported();
  }
}

当然不是。从 Java IO 的设计来看，装璜器模式有两个比拟非凡的中央：

装璜器类和原始类继承同样的父类，这样咱们能够对原始类“嵌套”多个装璜器类。

InputStream in = new FileInputStream("content.txt");
InputStream bin = new BufferedInputStream(in);
DataInputStream din = new DataInputStream(bin);
int data = din.readInt();

装璜器类是对性能的加强，这也是装璜器模式利用场景的一个重要特点。

代理模式中，代理类附加的是跟原始类无关的性能，而在装璜器模式中，装璜器类附加的是跟原始类相干的加强性能。

Shape

public abstract class Shape {public abstract void draw();

    public abstract void doOther();}

Circle

public class Circle extends Shape {

    @Override
    public void draw() {System.out.println("You are drawing circle...");
    }

    @Override
    public void doOther() {System.out.println("You are doing other...");
    }

}

Square

public class Square extends Shape {

    @Override
    public void draw() {System.out.println("You are drawing square...");
    }

    @Override
    public void doOther() {System.out.println("You are doing other...");
    }

}

ShapeDecorator

public class ShapeDecorator extends Shape {

    protected Shape shape;

    public ShapeDecorator(Shape shape) {this.shape = shape;}

    @Override
    public void draw() {shape.draw();
    }

    @Override
    public void doOther() {shape.doOther();
    }

}

RedShapeDecorator

public class RedShapeDecorator extends ShapeDecorator {public RedShapeDecorator(Shape shape) {super(shape);
    }

    @Override
    public void draw() {shape.draw();
        System.out.println("The shape color is red");
    }

}

Main

public class Main {public static void main(String[] args) {
        Shape shape;
        RedShapeDecorator decorator;

        shape = new Circle();
        decorator = new RedShapeDecorator(shape);
        decorator.draw();
        decorator.doOther();

        shape = new Square();
        decorator = new RedShapeDecorator(shape);
        decorator.draw();
        decorator.doOther();}

}

关于设计模式:设计模式之装饰器模式

利用场景

聊聊 Java IO 类

继承的问题

装璜器模式是简略的“用组合代替继承”吗？

跟代理模式的区别

类图

代码实现