（最近刚来到简书平台，以前在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类似，所以就不再举例说明了。
以上为本篇的全部内容。