JAVA面向对象编程学习 (8)异常处理与输入输出

异常

捕捉异常

常用的捕捉异常的语句

		try {//可能发生异常的语句段
			a[idx]=0;
			System.out.println(a[idx]);
		}catch (ArrayIndexOutOfBoundsException e) {
			System.out.print("数组下标越界");
		}

异常捕捉机制

抛出异常

	public static int open()
	{
		return 1;
	}
	
	public static void readfile() throws OpenException
	{
		if(open()==-1)
		{
			throw new OpenException();
		}
	}
	public static void main(String s[])
	{
		try{//如果函数的类型是有可能会抛出异常的，应当在调用时用try和catch
			readfile();
		}
		catch(OpenException e){
			
		}
	}

也就是说你的函数如果可能抛出异常，那么必须在函数增加声明，而且抛出异常的类型必须相对应
同时有一点是值得注意的，一个子类的异常，可以被父类的异常捕捉器所捕捉在捕捉异常的时候，是根据代码的书写顺序来捕捉的，假如父类的捕捉catch写在子类的catch之前，那么就会报错，因为异常捕捉器根本没办法到底后面的子类捕捉器去。
那么根据这一点，Exception类就可以捕捉系统中的所有异常。
但是根据这个情况，我们并不需要在JAVA程序内每个操作都写上这样的异常处理，程序如果遇到这样的情况，是会自动终止的，一般来说，这样的常见异常(除于0、空对象指针操作、数组下标越界)这些，是需要我们通过业务逻辑来处理的，大量的简单抛出异常会导致我们的程序臃肿难看。

当异常遇到继承

如果调用一个声明会抛出异常的函数那么必须：
把函数的调用放在try块中，并设置catch来捕捉所有可能的异常
声明自己会抛出无法处理的异常

当覆盖一个函数(@override)的时候：
子类不能声明抛出比父类的版本更多的异常
在子类的构造函数中，必须声明父类可能抛出的全部异常

流

流是输入输出的方式，流是一维单向的

流的基础类

InputStream
OurputStream

package hello;

import java.io.IOException;

public class helloworld 
{
	public static void main(String s[])
	{
		System.out.println("helloworld");
		//Scanner in =new Scanner(System.in);//初始化构造
		byte[] buffer=new byte[1024];
		try {
			int len =System.in.read(buffer);
			String string=new String(buffer,0,len);
			System.out.println("输出了"+len+"个字节");
			System.out.print(string);
			System.out.println("string的长度为:"+string.length());
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}

流过滤器

定义:以一个介质流对象为基础 层层构建过滤器流，最终形成的流对象能在数据的输入输出过程中，逐层使用过滤器流的方法来读写数据。

		System.out.println("helloworld");
		//Scanner in =new Scanner(System.in);//初始化构造
		byte[] buffer=new byte[10];
		for(int i=0;i<10;i++)
		{
			buffer[i]=(byte)i;
		}
		try {
			DataOutputStream outputStream=new DataOutputStream(
					new BufferedOutputStream(new FileOutputStream("a.dat"))
					      );
			int arg=0x3f3f3f3f;
			outputStream.writeInt(arg);
			outputStream.close();
			
		}catch(IOException e){
			e.printStackTrace();
		}

用以读写二进制表达的基本数据类型。

文本的输入和输出

文本数据采用Reader/Writer，可以用来处理Unicode字符
在流上建立文本处理

			PrintWriter pWriter=new PrintWriter(
					new BufferedWriter(
					new OutputStreamWriter(
					new FileOutputStream("a.txt"))));

package hello;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class helloworld 
{
	public static void main(String s[])
	{
		System.out.println("helloworld");
		//Scanner in =new Scanner(System.in);//初始化构造
		byte[] buffer=new byte[10];
		for(int i=0;i<10;i++)
		{
			buffer[i]=(byte)i;
		}
		try {
			PrintWriter pWriter=new PrintWriter(
					new BufferedWriter(
					new OutputStreamWriter(
					new FileOutputStream("a.txt"))));
			int arg=0x3f3f3f3f;
			pWriter.print(arg);
			pWriter.close();
			BufferedReader bufferedWriter= new BufferedReader(
					new InputStreamReader(
					new FileInputStream("src/hello/helloworld.java")));
			String lineString;
			while((lineString=bufferedWriter.readLine())!=null)
			{
				System.out.println(lineString);
			}
		bufferedWriter.close();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}

LineNumberReader()的用法:可以得到行号,getLineNumber();

FileReader
InputStreamReader类的子类,所有方法都从父类继承而来
FileReader(File file):在给定从中读取数据的File的情况下创建一个新FileReader
FileReader(String FileName):从给定从中读取数据的文件名的情况下创建一个新FileReader
FileReader不能指定编码转换方式

流的应用

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class SocketNet {

	public static void main(String[] args) 
	{
		try {
			Socket scSocket=new Socket(InetAddress.getByName("localhost"),8080);
			
			//现在要做的是往服务器上写东西
			PrintWriter pWriter=new PrintWriter(
					new BufferedWriter(
					new OutputStreamWriter(
				    scSocket.getOutputStream() )));//原本最后面是给的一个文本流的对象，现在因为是变成了写东西上服务器，所以就变成了socket的对象
					//得到了一个虚拟的流，依次送东西过去
			pWriter.print("helloworld!");
			
			//现在要做的是往服务器上读东西
			BufferedReader bufferedReader=new BufferedReader(
					new InputStreamReader(
					scSocket.getInputStream()));
			String line;
			while((line=bufferedReader.readLine())!=null)
			{
				System.out.println(line);
			}
			
			scSocket.close();
			pWriter.close();
			
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

在这里使用8080端口监听事件的时候，如果我们不往服务端上输入任何东西，程序就会在read的那一行停下来,这实际上就是一种阻塞机制
所以经常使用单独的线程来做socket读的等待，或者使用nio的channel选择机制
对于Socket，可以设置SO时间
setSoTimeOut(int timeout)