JAVA 输入输出异常线程

第九章Java高级编程知识点：流线程

异常处理重点、难点：文件字节流异常处理和自定义异常线程的创建和运行关键词：

InputStream、OutputStream、PrintStream

FileInputStream、FileOutputStream、

System.in、System.out

运行时异常、非运行时异常Throwable、ExceptionThrow、Throws

Thread、Runnable

一、流、输入流、输出流的概念1.关于流的定义不同的教材有不同的说法：流是指在计算机的输入输出之间流动的一个数据序列，其从数据源串行地流向数据的目的地；流是传递数据信息的载体，是程序中数据所经历的路径；

流是一种抽象的发送和接收数据的方法；

流是提供了一条通道的程序，可以使用这条通道把数据源中的数据传送到目的地；

流是一组有序的有起点有终点的数据集合；

说法不同，但它们都围绕着数据这个元素，考虑的问题是：数据数据从哪里来？数据到哪里去？同时也隐含指出了数据怎么来、数据怎么去的问题。

例如：全班同学要从桂林去南宁数据：全班学生数据源（数据的来源）：桂林目的地（数据的去处）：南宁怎么从桂林来：公路铁路空中航线怎么到南宁去：公路铁路空中航线流

进一步按来去方向分类：数据：data

数据源：source

来的方法：

method11method12……..数据：data目的地：destination

去的方法：

method21method22……..Java输入流Java输出流

2.输入流：将数据从数据源传给程序，这个数据源可以是文件，内存，或是网络连接等。

数据源程序输入流

3.输出流：可将数据送到目的地，目的地可以是文件，内存，或是网络连接等

程序目的地输出流

数据源输入运算输出目的地输入流Java程序设计中，输入数据可以用输入流从数据源中得到，输出数据可以输出流来输送到目的地

程序输出流

Java系统中根据数据的来源和去处的不同，提供了一系列的输入流和输出流类，统一组织在java.io包中，编程时利用它们，实现不同的输入/输出的数据处理。

二、字节流1、概述

输入字节流部分类的继承关系图

输出字节流部分类的继承图m字节输入流类：InputStream

字节输出流类：OutputStream它们是所有字节流的父类，是将数据以字节为基本处理单位的流它们是抽象类，实际编程中使用它们的子类

2、相关设计模式

Java的字节流在第一层子类上采用了适配器（Adapter)模式在第二层子类上采用了装饰（Decorator）模式。这些模式的使用使得Java的I/O流在使用上具有与众不同的特点。

1)适配器（Adapter)模式适配器模式类图

问题：什么情况下使用Adapter模式？两个不同的类或接口，但功能相同或相近，用适配器模式将两个类加以转换，还可以补充源没有的方法，而目标需要的方法。例：一个老师会讲课（只会用中文），也能完成项目工程，另一个工程师会用英语上课，利用他们两个人来完成用英语上课，同时又完成工程项目.

classTeacher{

Stringname;

publicvoidspeck(){

System.out.println(“这个技术的难点是：。。。。");}publicvoiddoProject(){

System.out.println(“完成了项目工程");}}classEngineer{

Stringname;

publicvoidspeck(){

System.out.println(“thedifficultyofthisTechnologyis:…..");}}

classAdaextendsTeacher{Engineerobj;

intage;

publicvoidspeck(){

obj=newEngineer();

obj.speck();

obj.doProject();}

}

publicclassUser{

publicstaticvoidmain(String

args[]){

Teachersm=newAda();

sm.speck();

sm.doProject();}}

publicclassUser1{

publicstaticvoidmain(String

args[]){

Teachersm=newTeacher();

sm.speck();

sm.doProject();}}

FileInputStream是一个适配器类适配器FileInputStream类图

2)装饰(Decorator)模式

DataInputStream等类是具体的装饰类

DataOutputStream等类是具体的装饰类

看下图：

兼职的学生：如果要增加学生的功能或职责，可采用装饰模式进行扩展

三。字节流的使用

1.InputStream与OutputStream

InputStream是字节输入流，它包含的三面的信息是：数据：字节用于程序从数据源中获取数据主要方法：

InputStream类的主要方法：abstractintread():从输入流中读取一个字节，返回0到255之间的一个数，遇到结尾返回-1。int

read(byteb[]):从输入流中读取长度为b.length的字节数到b,并返回读取字节数。遇到结尾返回-1。intread(byteb[],int

off,int

len):从输入流中读取长度为len的字节数到off开始的数组b，并返回读取字节数。遇到结尾返回-1。

OutputStream是字节输出流，它包含的三面的信息是：数据：字节用于将数据送到目的地主要方法：

OutputStream类的主要方法：abstractvoidwrite(intb):将指定的字节b写入输出流，如果b>255,则只写入其低位字节。voidwrite(byteb[]):把字节数组b中的b.length个字节写入输出流。voidwrite(byteb[]，int

off,int

len):把字节数组b中off开始长度为len个字节写入输出流。

2。File类：并不属于流，但主要应用于流技术中，所以Java把它放入了java.io包中

计算机文件基本上分为二种：二进制文件和ASCII码（也称纯文本）文件，除了纯文本文件外，其它的所有文件都是二进形式的文件，例如图形文件JPG、GIF等及文字处理文件如word,Excel等文件等都属于二进制文件,这些文件含有特殊的格式及计算机代码，需要专门的软件才能打开进行查看。而文本文件则可由任意软件处理。

File类

构造方法：

File(Stringname)

File(String

path,Stringname)

File(File

file,Stringfilename)

3。FileInputStream和FileOutputStream

FileInputStream是文件字节输入流，它包含的三方面的信息是：数据：字节用于程序从数据源---文件中获取数据主要方法：重写或继承于父类

主要构造方法：

FileInputStream(Stringname)

FileInputStream(File

fileObject)它们有可能引发FileNotFoundException异常

例读取文本文件的内容并显示输出思考过程：初始建模

为了满足“开---闭”原则，进一步抽象

例9_1

importjava.io.*;publicclassReadTextFile{StringfileName;//要读取的文件名

publicReadTextFile(){}publicReadTextFile(Strings){

fileName=s;

}

publicStringread1(){

try{Filef=newFile(fileName);

FileInputStreamfin=new

FileInputStream(f);byte[]b=newbyte[(int)f.length()];Strings=null;

fin.read(b);s=newString(b);returns;}catch(Exception

e){returnnull;}}

publicStringread1(Stringfn){try{Filef=newFile(fn);

FileInputStreamfin=newFileInputStream(f);byte[]b=newbyte[(int)f.length()];Strings=null;

fin.read(b);s=newString(b);returns;}catch(IOException

e){returnnull;}}}

publicStringoutPut(){return("文件"+fileName+"的内容是："+read1());}}

publicclassUser{

publicstaticvoidmain(String

args[]){

try{

ReadTextFile

obj=newReadTextFile("a.txt");

System.out.println(obj.outPut());

ReadTextFileobj1=newReadTextFile("User.java");Strings1=obj1.read1();System.out.println(s1);}catch(Exceptione){}}}

注意：

1.从文件输入流中读文本文件到显示器输出的方法

2.一般只有纯文本文件才考虑采用上述方法输出到显示器进行查看，二进制文件不能直接地输出到显示器，因这它们是需要特殊的软件才能打开的。

如果上例把Filef=newFile(“a.txt”);改成Filef=newFile(“a.doc”);会有什么输出结果？

FileOutputStream类

OutputStream是字节输出流，它包含的三面的信息是：数据：字节用于将数据送到目的地---文件主要方法：重写或继承了父类的方法

主要的构造方法：FileOutputStream(Stringname)FileOutputStream(String

name,booleanappend)FileOutputStream(File

fileObj)它们有可能引发IOException或SecurityException

例将文本文件的内容写入文件思考过程：初始建模

importjava.io.*;publicclassWriteTextFile{StringwriteFileName;

publicWriteTextFile(){}publicWriteTextFile(Stringsout){

writeFileName=sout;}

publicvoidgetOutPut(Strings){

try{Filef=newFile(writeFileName);

FileOutputStream

fout=new

FileOutputStream(f);

fout.write(s.getBytes());

fout.close();}

catch(IOExceptione){}}

publicStringread1(Stringfn){try{

FileInputStreamfin=new

FileInputStream(fn);byte[]b=newbyte[(int)f.length()];Strings=null;

fin.read(b);s=newString(b);returns;}catch(IOException

e){returnnull;}}

4.DataInputStream和

DataOutputStream

它可以按java的数据类型读取数据构造方法：

DataInputStream（InputStreamins);

DataOutputStream(OutputStreamouts);

DataInputStream主要方法：

int

readInt()bytereadByte()longreadLong()StringreadUTF()

boolean

readBoolean()

int

readInt()floatreadFloat()shortreadShort()charreadChar()

DataOutputStream主要方法：

voidwrite(byteb[])voidwriteInt(intb)voidwriteShort(shortb)voidwriteLong(longl)voidwriteChar(charc)voidwriteFloat(floatf)voidwriteDouble(doublef)voidwriteUTF(Strings)voidwriteBoolean(booleanb)

例：将电话号码（长整型数）存入文件中

importjava.io.*;publicclassWriteFile{Strings;//文件名

publicWriteFile(){}publicWriteFile(Stringsout){

s=sout;}

publicvoidwrite1(longphone_number){try{Filef=newFile(s);

OutputStream

fout=newFileOutputStream(s);

DataOutputStream

dout=new

DataOutputStream(fout);

dout.writeLong(phone_number);

dout.close();}

catch(IOExceptione){}}

publicvoidwrite1(StringfileName,longph){try{Filef=newFile(fileName);

OutputStream

fout=newFileOutputStream(f);

DataOutputStream

dout=newDataOutputStream(fout);

dout.writeLong(ph);

dout.close();}

catch(IOExceptione){}}publiclongread1(StringfileName){longph=0;try{Filef=newFile(fileName);

InputStreamfin=newFileInputStream(f);

DataInputStreamdin=newDataInputStream(fin);ph=din.readLong();

din.close();}

catch(IOExceptione){}

finally{returnph;}}}

importjava.util.*;publicclassUseWriteFile{

publicstaticvoidmain(String

args[]){

try{Scannersc=newScanner(System.in);

System.out.println("请输入你要存入文的内容：");Stringinf=sc.nextLine();Longph=Long.parseLong(inf);

WriteFile

obj=newWriteFile("a.dat");obj.write1(ph);

System.out.println("已存入文件");System.out.println(obj.read1("a.dat"));}catch(Exceptione){}}}

5。标准输入/输出流对象

Java的System类中定义的类变量：

publicstaticPrintStreamout;publicstaticInputStreamin;

System.in：它是由系统自动创建的InputStream的一个输入流对象，用来接收键盘的输入的数据。System.out:它是OutputStream的子类PrintStream的一个输出流对象，能够输出数据到显示器。

.字节输出流PrintStream：可以输出各种类型的数据

构造方法：

PrintStream(OutputStreamout);

在其父类OutputStream上增加的主要方法：

voidprintln(）

voidprintln(booleanb)

voidprintln(charc）

voidprintln(char[]c）

voidprintln(doubled）

voidprintln(floatf）

voidprintln(inti）

voidprintln(longl）

voidprintln(Objectobj）

voidprintln(Stringstr）将各种类型的数据输出到输出流

四.序列化(串行化或可持续化)

序列化是把一个对象的状态保存起来；从该区域读取对象状态即称为反序列化。实现了Serializable接口的类的对象才可以序列化。

Serializable接口中没有任何方法，只是做为一个标记来指示该类的对象可以序列化

主要由以下两个类实现：

ObjectOutputStream

ObjectInputStream

向流写入对象和从流中读取对象

构造方法：

ObjectOutputStream(OutputStream

os);

ObjectInputStream(InputStreamis);

ObjectInputStream主要方法：

ObjectreadObject()

ObjectOutputStream主要方法：

writeObject(Object

obj)

例将学生信息的内容写入文件思考过程：初始建模

importjava.io.*;classStudentimplementsSerializable{ Stringname;String

password;intage;publicStudent(){ Stringname="2";Stringpassword="2";intage=20; } publicStudent(String

name,String

password,intage){

=name;

this.password=password;

this.age=age; } publicvoidsetPassword(Stringpass){

this.password=pass; }publicStringgetPassword(){ returnpassword; }publicvoidsetName(Stringname){

=name; }publicStringgetName(){ returnname; }publicvoidsetAge(intage){

this.age=age; }publicint

getAge(){ returnage; }}

publicclassUseObjectStream{publicObjectread1(StringfileName){try{

FileInputStream

fis=newFileInputStream(fileName);

ObjectInputStream

ois=newObjectInputStream(fis); returnois.readObject();}

catch(Exception

e){returnnull;}

}publicvoidwrite1(StringfileName,Object

obj){try{

FileOutputStream

fos=newFileOutputStream(fileName,true);

ObjectOutputStream

obs=newObjectOutputStream(fos);

obs.writeObject(obj);}

catch(Exceptione){} }}

importjava.io.*;publicclassUser{ publicstaticvoidmain(String

args[]){ Students1=newStudent("Tom","111",21);

UseObjectStream

vip=newUseObjectStream(); try{ vip.write1("customer.obj",s1);

System.out.println("用户信息写入文件"); Studentvip1=(Student)vip.read1("customer.obj");

System.out.println("文件中的信息为：");

System.out.println("用户名："+vip1.getName());

System.out.println("密码："+vip1.getPassword());

System.out.println("年龄："+vip1.getAge());

} catch(Exceptione){

e.printStackTrace(); }}}

五.Scanner类Scanner是JDK1.5新增的一个类，是java.util包中的类。该类用来实现用户的输入;

构造方法:（1）Scanner(InputStreamin)

（2）Scanner(Filefile)

主要方法：将控制台输入信息扫描为相应的数值

Stringnext()StringnextLine()

boolean

nextBoolean()

bytenextByte()

doublenextDouble()

floatnextFloat()

int

nextInt()

longnextLong()

shortnextShort()

异常相关知识一.引入class旅游{publicstaticvoidmain(String[]args){

买票;//可能买不到坐车;//可能路途中车坏了

住宿;//可能找不到住处}}问题：未对可能的出现的问题进行处理,此时如果出现问题,旅游将会被迫终止.class旅游{publicstaticvoidmain(String[]args){

买票;//可能买不到

if(买不到){……}

坐车;//可能路途中车坏了

if(车坏了){……..}

住宿;//可能找不到住处

if(找不到住处){……..}}}

缺点:1）模糊了问题求解的逻辑，要考虑大量非正常的情况并做出处理，有时这种情况出现的机会很少，这使得程序设计变得复杂。2）程序员对非正常问题的处理的能力在很大程度上影响编程工作效率和质量。3）层层处理太麻烦，程序可读性降低。二、异常程序设计时把可以预见的非正常现象称为异常。这种异常程序是可以处理的。

在完成特定功能的同时，具有完善的异常处理能力才是合格的，具有健壮性的程序。

1.Java的异常处理异常处理就是允许用户有排除错误的机会，或至少能给出适当的出错提示信息。

Java中定义了很多异常类，用来描述经常较容易发生的错误，当程序运行时发生了该类异常，就产生一个收集了异常信息的异常对象，我们通过捕捉或抛出来处理这个对象。

通过异常处理机制处理程序中可能发生的问题:

class旅游{publicstaticvoidmain(String[]args){try{买票;

坐车

住宿;}

catch(Exceptione){给出各种错误处理的信息和处理方法等;}}}

这些类都继承自java.lang.Throwable类。Throwable类有两个子类：Error和Exception，它们分别表示两种异常类型。…….Error类及其子类通常用来描述Java运行系统中的内部错误以及资源耗尽的错误。Error表示的异常是比较严重，仅靠修改程序本身是不能恢复执行的，被称为致命异常类。例如，前面所说的旅游，因为想去旅游的人在旅途中没有钱了,或者受伤了…….此时就相当于发生了一个Error异常。在大多数情况下，发生该异常时，建议终止程序。Exception类可称为非致命异常类，在开发Java程序过程中进行的异常处理，主要就是针对该类及其子类的异常处理。对程序中可能发生的该类异常，应该尽可能进行处理，而不应该在异常发生后终止程序。Exception类又分为两种异常类型：运行时异常（RuntimeException）非运行时异常

三、异常类Exception

构造函数

publicException();publicException(Strings);

常用方法：publicStringtoString()publicStringgetMessage()

1.RuntimeException可以预料，但不知何时何地发生，例如：旅游过程中坐公共汽车不买票,吃饭不给钱……这种异常一般不用处理，处理的开销太大，如果发生Java虚拟机系统会自动处理。

常见的RuntimeException异常如下表所示：异常类名称异常类含义ArithmeticException算术异常类ArrayIndexOutOfBoundsException数组下标越界异常类ArrayStoreException将与数组类型不兼容的值赋值给数组元素时抛出的异常ClassCastException类型强制转换异常类IndexOutOfBoundsException当某对象(如数组或字符串)的索引超出范围时抛出该异常NegativeArraySizeException建立元素个数为负数的数组异常类NullPointerException空指针异常类NumberFormatException字符串转换为数字异常类SecurityException小应用程序(Applet)执行浏览器的安全设置禁止的动作时抛出的异常StringIndexOutOfBoundsException字符串索引超出范围异常2。非运行时异常可以预料，知道何时何地可能会发生，如：旅游过程中买不到票,找不到住处……，出现这种情况时要求通过try…catch捕获或由throws抛出。Java语言中常见的非运行时异常如下表所示:异常类名称异常类含义ClassNotFoundException未找到相应类异常EOFException文件已结束异常类FileNotFoundException文件未找到异常类IllegalAccessException访问某类被拒绝时抛出的异常InstantiationException试图通过newInstance()方法创建一个抽象类或抽象接口的实例时抛出该异常IOException输入输出异常类NoSuchFieldException字段未找到异常NoSuchMethodException方法未找到异常SQLException操作数据库异常类四、异常处理的方式

对运行异常可以不做处理，也就是说程序设计时不需要增加异常处理语句，Java虚拟机系统会自动进行处理;但是如果你能确定它发生的时间和地点，你也可以对它进行处理。

对非运行时异常，则需要进行处理，否则编译通不过。

1.捕捉异常：

程序设计时使用try-catch-finally语句进行处理

语法格式：try{代码0(可能产生异常的代码)}catch(例外类1e){例外处理代码1；}…catch(例外类ne){例外处理代码n；}finally{必须执行的代码；}

importjava.io.*;classTryCatchTest{publicstaticvoidmain(String

agrs[]){Filefile=newFile("abc.txt");

inta[]={1,2};try{System.out.println(3/0);}

catch(ArithmeticExceptione){System.out.println("3/0");

System.out.println("ThisisArthmeticException");}try{System.out.println(a[2]);}

catch(ArrayIndexOutOfBoundsExceptione){System.out.println("a[2]");

System.out.println("ThisisArrayIndexOutOfBoundsException");}

try{FileInputStreamfin=newFileInputStream(file);}

catch(FileNotFoundExceptione){

System.out.println("abc.txtisnotfound");

System.out.println("ThisisFileNotFoundException");}

catch(IOExceptione){

System.out.println("ThisisIOException");}

}}2.通过throws语句声明抛出，交给调用它的方法进行处理

这时方法的定义格式：

方法名（[参数表]）throws例外名列表

publicclassPeople{ publicint

check(String

strage)throwsException{

intage=Integer.parseInt(strage);

if(age<0) thrownewException(“年龄不能为负数！”); returnage; }}classUsePeople{ publicstaticvoidmain(String[]args){ try{ Peoplep=newPeople();

int

myage=p.check("-101");

System.out.println(myage); }catch(Exceptione){

System.out.println("数据逻辑错误！");

System.out.println("原因："+e.getMessage()); } }}五、自定义异常

步骤：1、创建继承Exception的异常类,主要定义构造方法和重写toString()方法,目的是给出适当的出错提示信息，让用户有机会排除错误。

publicclassE1extendsException{privateStringmessage;publicE1(Strings){message=s;}publicStringtoString(){returnmessage;}2、定义某一个方法在一定条件下产生这种异常对象，并用throws语句抛出该对象。

方法定义格式：

[修饰符]返回类型方法名（参数。。。）throws自定义异常

{if(…..)throw(自定义的异常对象)……}

3、其它方法调用该方法例：

testimportjava.io.*;classMyExp1extendsException{publicStringtoString(){return"自已定义的异常产生了";}}publicclassTest{publicvoidlogin(Stringa)throwsMyExp1{if(a.equals("李明")){MyExp1e=newMyExp1();throwe;}

}publicstaticvoidmain(String

arg[]){try{Testt1=newTest();t1.login("李明");}catch(MyExp1e){System.out.println(e.toString());}}}

线程相关知识

一、引入看一个例子：

classParent{StringpName;publicStringdoHousework(String

dosomething){return(dosomething);}}

publicclassStudent{StringsName;publicStringdoHomework(Stringsubject){return“完成”+subject;}}

classUseStudent{ publicstaticvoidmain(String

args[]){ Studenta=newStudent();

a.sName="李小明";Parentb=newParent();

b.pName="李大明";

System.out.println(a.doHomework(“语文作业！”));

System.out.println(b.doHousework(“拖地板"));}}二、线程的创建

Java语言中，线程也是一种对象，但并非任何对象都可以成为线程，只有实现Runnable接口或继承了Thread类的对象才能成为线程。

两种线程的实现方法：1.继承Thread类

classParentextendsThread{StringpName;publicStringdoHousework(String

dosomething){return(dosomething);}

publicvoidrun(){try{

System.out.println(pName+doHousework(“拖地板"));

Thread.sleep(1000); }catch(Exceptione){

e.printStackTrace(); }}}

publicclassStudentextendsThread{StringsName;

publicStringdoHomework(Stringsubject){return"