6-Java IO-装饰模式

1.Java IO分类

节点流-过滤流

输入流-输出流

字节流-字符流

2.InputStream，节点输入字节流的祖宗，抽象类

read()：留给子类实现

public abstract int read() throws IOException;

read(byte b[])：0偏移，塞满数组b

public int read(byte b[]) throws IOException {
return read(b, 0, b.length);
}

read(byte b[], int off, int len)：可以看到，其实就是一个字节一个字节地读取，塞入字节数组b

public int read(byte b[], int off, int len) throws IOException {
if (b == null) {
throw new NullPointerException();
} else if (off < 0 || len < 0 || len > b.length - off) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
}
int c = read();
if (c == -1) {
return -1;
}
b[off] = (byte)c;
int i = 1;
try {
for (; i < len ; i++) {
c = read();
if (c == -1) {
break;
}
b[off + i] = (byte)c;
}
} catch (IOException ee) {
}
return i;
}

3.FileInputStream，节点流，继承自InputStream

read()：native搞起

public int read() throws IOException {
return read0();
}
private native int read0() throws IOException;

read(byte b[])：还是native

public int read(byte b[]) throws IOException {
return readBytes(b, 0, b.length);
}
private native int readBytes(byte b[], int off, int len) throws IOException;

read(byte b[], int off, int len)：native

public int read(byte b[], int off, int len) throws IOException {
return readBytes(b, off, len);
}
private native int readBytes(byte b[], int off, int len) throws IOException;

4.DataInputStream，过滤流，继承FilterInputStream实现DataInput

read(byte b[])：

这个in是个InputStream的引用，这就是装饰模式；

那么，这个in是什么时候进来的呢，是在DataInputStream的构造方法里进来的

public final int read(byte b[]) throws IOException {
return in.read(b, 0, b.length);
}

read(byte b[], int off, int len)：

public final int read(byte b[], int off, int len) throws IOException {
return in.read(b, off, len);
}

readInt()：

public final int readInt() throws IOException {
int ch1 = in.read();
int ch2 = in.read();
int ch3 = in.read();
int ch4 = in.read();
if ((ch1 | ch2 | ch3 | ch4) < 0)
throw new EOFException();
return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
}

5.装饰模式

InputStream：被装饰者

FileInputStream：具体被装饰者

FilterInputStream：装饰者

DataInputStream：具体装饰者

关系：

abstract class InputStream

FileInputStream extends InputStream

FilterInputStream extends InputStream

DataInputStream extends FilterInputStream implements DataInput

6.半透明装饰

首先，说一说透明装饰，或者说理想的装饰模式，那当然是具体装饰者的方法集合，不要超出被装饰者的；这样的话，当我们在业务方法中调用装饰者（往往是接口或者抽象类的一个引用）方法时，就不用担心转型问题；说道这里可能还是很迷糊，那么说个例子，PushbackInputStream。

PushbackInputStream extends FilterInputStream

先看下常规使用装饰模式：

public Client{
private InputStream in;
public Client(InputStream in){
this.in = in;
}
......
public void read(byte[] b){
in.read(b, 0, b.length);
}
}
Socket socket = ...;
byte[] b = ...;
Client client = new Client(socket.getInputStream());
client.read(b);

那么上面这个是ok的，不会有什么问题。

然后，这个时候由于我知道PushbackInputStream这个类，完了我还想用它提供的unread方法。

public Client2{
private InputStream in;
public Client2(InputStream in){
this.in = in;
}
......
public void unread(int b){
in.unread(b);
}
}
Socket socket = ...;
int b = ...;
Client2 client2 = new Client2(new PushbackInputStream(socket.getInputStream()));
client2.unread(b);

那么，这个时候就有问题了，因为unread这个方法是PushbackInputStream（可以认为是个具体装饰者）特有的，InputStream里压根没有。那么Client2的这个unread方法是有问题的，他需要改成这样:

public void unread(int b){
((PushbackInputStream)in).unread(b);
}

那么，说到这个半透明装饰，倒不能说是PushbackInputStream不好，毕竟人家提供额外的unread方法，只是我们自己使用的时候需要注意到这个点。