File类与常用IO流第六章——使用try...catch...finally处理流中的异常

在JDK1.7之前：

 1 package com.itheima.demo06.trycatch;
 2
 3 import java.io.FileWriter;
 4 import java.io.IOException;
 5
 6 /*
 7     在jdk1.7之前使用try catch finally 处理流中的异常
 8     格式:
 9         try{
10             可能会产出异常的代码
11         }catch(异常类变量 变量名){
12             异常的处理逻辑
13         }finally{
14             一定会指定的代码
15             资源释放
16         }
17  */
18 public class Demo01TryCatch {
19     public static void main(String[] args) {
20         //提高变量fw的作用域,让finally可以使用
21         //变量在定义的时候,可以没有值,但是使用的时候必须有值
22         //fw = new FileWriter("09_IOAndProperties\\g.txt",true); 执行失败,fw没有值,fw.close会报错
23         FileWriter fw = null;
24         try{
25             //可能会产出异常的代码
26             fw = new FileWriter("w:\\09_IOAndProperties\\g.txt",true);
27             for (int i = 0; i <10 ; i++) {
28                 fw.write("HelloWorld"+i+"\r\n");
29             }
30         }catch(IOException e){
31             //异常的处理逻辑
32             System.out.println(e);
33         }finally {
34             //一定会指定的代码
35             //创建对象失败了,fw的默认值就是null,null是不能调用方法的,会抛出NullPointerException,需要增加一个判断,不是null在把资源释放
36             if(fw!=null){
37                 try {
38                     //fw.close方法声明抛出了IOException异常对象,所以我们就的处理这个异常对象,要么throws,要么try catch
39                     fw.close();
40                 } catch (IOException e) {
41                     e.printStackTrace();
42                 }
43             }
44
45         }
46     }
47 }

JDK1.7：

 1 import java.io.FileInputStream;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4
 5 /*
 6     JDK7的新特性
 7     在try的后边可以增加一个(),在括号中可以定义流对象
 8     那么这个流对象的作用域就在try中有效
 9     try中的代码执行完毕,会自动把流对象释放,不用写finally
10     格式:
11         try(定义流对象;定义流对象....){
12             可能会产出异常的代码
13         }catch(异常类变量 变量名){
14             异常的处理逻辑
15         }
16  */
17 public class Demo02JDK7 {
18     public static void main(String[] args) {
19         try(//1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
20             FileInputStream fis = new FileInputStream("c:\\1.jpg");
21             //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
22             FileOutputStream fos = new FileOutputStream("d:\\1.jpg");){
23
24             //可能会产出异常的代码
25             //一次读取一个字节写入一个字节的方式
26             //3.使用字节输入流对象中的方法read读取文件
27             int len = 0;
28             while((len = fis.read())!=-1){
29                 //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
30                 fos.write(len);
31             }
32
33         }catch (IOException e){
34             //异常的处理逻辑
35             System.out.println(e);
36         }
37
38
39     }
40 }

JDK1.9：

 1 import java.io.FileInputStream;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4
 5 /*
 6     JDK9新特性
 7     try的前边可以定义流对象
 8     在try后边的()中可以直接引入流对象的名称(变量名)
 9     在try代码执行完毕之后,流对象也可以释放掉,不用写finally
10     格式:
11         A a = new A();
12         B b = new B();
13         try(a,b){
14             可能会产出异常的代码
15         }catch(异常类变量 变量名){
16             异常的处理逻辑
17         }
18  */
19 public class Demo03JDK9 {
20     public static void main(String[] args) throws IOException {
21         //1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
22         FileInputStream fis = new FileInputStream("c:\\1.jpg");
23         //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
24         FileOutputStream fos = new FileOutputStream("d:\\1.jpg");
25
26         try(fis;fos){
27             //一次读取一个字节写入一个字节的方式
28             //3.使用字节输入流对象中的方法read读取文件
29             int len = 0;
30             while((len = fis.read())!=-1){
31                 //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
32                 fos.write(len);
33             }
34         }catch (IOException e){
35             System.out.println(e);
36         }
37
38         //fos.write(1);//Stream Closed
39
40     }
41 }