两个角度看JAVA的IO流

     这个存在心中的顾虑，在某个时候有一点放宽。本来觉得io流已经掌握了，可是当用起来那时，还是显得没有那么得心应手。古语有云：横看成岭侧成峰。一个问题，从多几个角度去看的话，会觉得明白很多。从一个侧面到另外一个侧面去看。

两个角度：一个角度，decorator设计模式；另一个从传统学习的知识完备性出发（API）。

 

一、Decorator设计模式看IO

     

 

 

 UML图很明显了，下面看一个Cat例子：

对应于上图：

Cat-----Component

public interface Cat {
	void behavior();
}

 

SmallCat----ConcreteComponent

public class SmallCat implements Cat {
	private String name;

	SmallCat() {
	}

	SmallCat(String name) {
		this.name = name;
	}

	public void behavior() {
		// TODO Auto-generated method stub
		System.out.print("I'm small cat! My name is " + name);
	}
}

 

Decorator----Decorator

public interface Decorator extends Cat {
	public void add() ;
}

 

DecoratorDress----ComcreteDecorator1

public class DecoratorDress implements Decorator {
	private Cat cat;

	public DecoratorDress(Cat cat) {
		this.cat = cat;
	}

	public void behavior() {
		cat.behavior();
		add();
	}

	public void add() {
		System.out.print(",dressing");
	}
}

 

DecoratorGlasses-----ComcreteDecorator2

public class DecoratorGlasses implements Decorator {
	private Cat cat;

	DecoratorGlasses(Cat cat) {
		this.cat = cat;
	}

	public void add() {
		System.out.print(",glassing");
	}

	public void behavior() {
		cat.behavior();
		add();
	}
}

 

main函数：

public class TestMain {
        public static void main(String[] args) {
              Cat scat = new SmallCat("xiao hua") ;
              DecoratorDress DressCat = new DecoratorDress(scat);
              DecoratorGlasses GlassesCat = new DecoratorGlasses(dcat) ;
              GlassesCat.behavior();		
	}
}

 

这里造了一个猫，然后，让这个小猫穿上衣服，再让它带上眼镜的。呵呵。。。。

言归正传，看看这个io是一个怎样一回事情，他们是这个关系：

这里有四个东西InputStream,OutputStream,Reader,Writer这个接口就构成了JAVA的IO上层。

四个的结构模式都是一样的，用InputStream来举一个例子：

InputStream----Component

FileInputStream同层之类的数据源等-----ComreteComponent

FilterInputStream过滤器----Decorator

DataInputStream同层之类等----ComreteComponent

这样就构成了。

看一例：昨天写的用JAVA实现的简单聊天，用一个client端的代码.

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.Socket;
public class Client01 {
	public static void main(String[] args) throws Exception {
		DataInputStream dis = null;
		System.out.println("client start..");
		Socket socket = new Socket("127.0.0.1", 8888);
		String str = null;
		while (true) {
			System.out.print("I say:");
			str = new BufferedReader(new InputStreamReader(System.in))
					.readLine();// 读入字符
			if (str.equalsIgnoreCase("88")) {
				break;
			}
			new DataOutputStream(socket.getOutputStream()).writeUTF(str);// 发送数据
			dis = new DataInputStream(socket.getInputStream());// 读入服务器信息
			System.out.println("server say:" + dis.readUTF());// 显示服务器信息
		}
		dis.close();
		socket.close();
	}
}

 这里就会看到很多的流的一个接一个情况。呵呵，写的时候头真的有点而昏。这个还得去配合Server端的。

 

好啦，这个就总结到这里了。

 

 

二 、功能分类看IO

     这个为了记忆，采用了下面这个方法去记忆了，IO流很多内容，但是想用得顺手还得去记得，还得去敲出来，下面这个从另一个角度看看IO，总结出这个树，没有考究过完整性，常用的估计也包括了。

 

|--基础流（从特定的数据源读写数据，目的：建立一个数据源）

        |--File  （文件源）

|--FileReader(FileWriter)

|--FileInputStream(FileInputStream)

|-Memory Array（内存数组源）

|--CharArrayReader(CharArrayWriter)

|--ByteArrayInputStream(ByteArrayOutputStream)

         |--Memory String （字符串源）

                  |--StringReader(StringWriter)

                   |--(对于字符串，字节没有必要有)

         |--Pipe（管道源）

                   |--PipedReader(PipedWrite)

                   |--PipedInputStream(PipedOutputStream)

|--高级流（连接在已经存在的流(节点流或处理流)之上，目的：让程序对数据的处理为程序提供更为强大的读写功能）

         |--Buffering（把数据源读到绶存，用来对数据的缓冲，目的：提高读写效率）

                   |--BufferedReader(BufferedWriter)

                   |--BufferedInputStream(BufferedOutputStream)

         |--Coverting （目的：让数据由字节向字符转换）

                   |--InuputSteamReader(OutputStreamWriter)

                   |--(没有字符流转成字节流的，这个可以用String中的getByte()函数)

         |--Data conversion（对特殊数据字节数处理（数据类型流））

                   |--(数据是与字符平起平坐的，不用经过字符，再去变成数字)

                   |--DataInputStream(DataOutputStream)

         |--Object Serialization

                   |--(解释同数据转换)

                   |--ObjectInputStream(ObjectOutputStream)

|--Printing(实现一个标准的输出，不分数据类型的，没有涉及到输入流的，不会有抛出出的异常)

                   |--PrintWriter()

                   |--PrintStream()

 

 

   好了，这个是我的一点java学习总结，分享交流一下，还存在不足，请各位指教。