（最近刚来到简书平台，以前在CSDN上写的一些东西，也在逐渐的移到这儿来，有些篇幅是很早的时候写下的，因此可能会看到一些内容杂乱的文章，对此深感抱歉，以下为正文）
正文
本篇讲述的是Java IO包中的FilterInputStream和FilterOutputStream类，老规矩，先附上两个类的源码。
FilterInputStream
package java.io;
public class FilterInputStream extends InputStream {
/**
* 内部声明了一个InputStream对象的句柄，用于接收传入的InputStream对象。同时用volatile关键字修饰，确保了数据改变时的可见性。
*/
protected volatile InputStream in;
/**
* 一个被protected关键字修饰的构造汉方，含义一个参数，参数类型为InputStream类型，将传入的InputStream对象赋值给声明的句柄in。
*/
protected FilterInputStream(InputStream in) {
this.in = in;
}
/**
* 定义了一个不带参的read方法，只是简单的调用了InputStream的read方法，每次读取一个字节的数据，用于读取流中数据。
*/
public int read() throws IOException {
return in.read();
}
/**
* 定义了一个带一个参数的read方法，内部实际上是调用了InputStream对应的read方法，每次可以通过传入的字节数组作为缓存区读取一片数据。
*/
public int read(byte b[]) throws IOException {
return read(b, 0, b.length);
}
/**
* 定义了一个带三个参数的read方法，内部实际上是调用了InputStream对应的read方法。可以通过传入的数组作为缓存，另外两个参数控制的是从缓存中读取的位置以
* 及长度，每次可以读取一片数据。
*/
public int read(byte b[], int off, int len) throws IOException {
return in.read(b, off, len);
}
/**
* 定义了一个带一个参数的skip方法，内部实质是调用InputStream中的skip方法。用于跳过指定长度的数据，进行数据读取。
*/
public long skip(long n) throws IOException {
return in.skip(n);
}
/**
* 定义了一个available方法，内部实质是调用了InputStream的available方法，用于获取流中仍可以读取字节数。
*/
public int available() throws IOException {
return in.available();
}
/**
* 定义了一个close方法，内部实质是调用了InputStream的close方法，用于关闭流。
*/
public void close() throws IOException {
in.close();
}
/**
* 定义了一个mark方法，内部实质是调用了InputStream的mark方法，用于在流中留下标记，与reset方法联合使用，可以回到标记处继续读取数据。
*/
public synchronized void mark(int readlimit) {
in.mark(readlimit);
}
/**
* 定义了一个reset方法，内部实质是调用了InputStream的reset方法，与mark方法联合使用，可以回到标记的地方继续读取数据。
*/
public synchronized void reset() throws IOException {
in.reset();
}
/**
* 定义了一个markSupported方法，内部实质是调用了InputStream的markSupported方法，返回的boolean值表示当前流是否支持标记功能。
*/
public boolean markSupported() {
return in.markSupported();
}
}
FilterOutputStream：
package java.io;
public class FilterOutputStream extends OutputStream {
/**
* 内部声明了一个OutputStream对象的句柄，用于接收传入的OutputStream对象。
*/
protected OutputStream out;
/**
* 一个带一个参数的构造函数，参数为一个OutputStream对象，将传入的OutputStream对象赋值给声明的句柄out。
*/
public FilterOutputStream(OutputStream out) {
this.out = out;
}
/**
* 定义了一个write方法，内部实质调用的是OutputStream对象的write方法，每次写人一个字节。
*/
public void write(int b) throws IOException {
out.write(b);
}
/**
* 定义了一个带一个参数的write方法，参数类型为一个byte类型数组，内部实质上调用了OutputStream对象的write方法。
*/
public void write(byte b[]) throws IOException {
write(b, 0, b.length);
}
/**
* 内部实质上调用的OutputStream的write方法，一次可以写入一段数据。
*/
public void write(byte b[], int off, int len) throws IOException {
if ((off | len | (b.length - (len + off)) | (off + len)) < 0)
throw new IndexOutOfBoundsException();
for (int i = 0 ; i < len ; i++) {
write(b[off + i]);
}
}
/**
* 定义了一个flush方法，内部实质上是调用了OutputStream对象的flush方法，保证数据已从缓存写入到目的地。
*/
public void flush() throws IOException {
out.flush();
}
/**
* 使用了try-resource的方式关闭流，同时调用flush方法，确保数据已经写出。
*/
@SuppressWarnings("try")
public void close() throws IOException {
try (OutputStream ostream = out) {
flush();
}
}
}
从上面的源码中可以看出，两个类中很多的方法其实仅仅只是直接调用了OutputStream的对应方法。那么它们的意义何在呢，其实这里面牵扯到了一种设计模式，就是装饰者模式（设计模式会在后面的篇幅中详细描述，这里就不细说了）。
这两个类本身的意义并不在与实现了什么而是定义了一个标准，具体的实现都是由它们的子类去实现的，如BufferedInputStream / BufferedOutputStram，DataInputStream / DataOutputStream，PrintStream等。它们都为InputStream / OutputStream添加了一些新的功能。
因为这两个类只是相当于定义了一个标准，但从功能上看与InputStream和OutputStream类似，所以就不再举例说明了。
以上为本篇的全部内容。
