1. 首页
  2. 文章中心
  3. Java编程

Java IO流—异常及捕获异常处理 try…catch…finally

213 阅读 0 评论
我是靠谱客的博主 可耐睫毛膏，这篇文章主要介绍Java IO流—异常及捕获异常处理 try…catch…finally，现在分享给大家，希望可以做个参考。

一、Java IO流

1、概念

  • 在Java中，把不同的输入源 / 输出源（如：键盘、文件、网络链接等）抽象的表述为“流”（stream）
  • 通过 ”流“ 的形式允许Java程序使用相同的方式访问不同的输入 / 输出源
  • Java 把所有传统的”流“放在了 java . io 包下

2、IO流的分类（按流向划分）

  • 输入流：只能从中读取数据，不能写入
  • 输出流：只能写入数据，不能读取数据

3、IO流的分类（按操作单元划分）

  • 字节流：操作单元是8位的字节，主要是 InputStream 和 OutputStream 作为基类
  • 字符流：操作单元是16位的字符，主要是 Reader 和 Writer 作为基类

4、IO流的分类（流的角色划分）

  • 节点流：可以向一个特定的 IO 设备（如磁盘等）读 / 写数据的流，也称为：低级流
  • 处理流：用于对一个已存在的流进行连接和封装，通过封装后的流来实现数据的读/写功能，也称为高级流

二、Java 异常

1、概述

  • Java在运行程序过程中出现的错误

2、常见的异常

  • 空指针异常类：NullPointerException
  • 类型强制转换异常：ClassCastException
  • 数组下标越界异常：ArrayIndexOutOfBoundsException
  • 算术异常类：ArithmeticExecption
  • 数组负下标异常：NegativeArrayException

3、异常的分类

三、异常处理方案

1、try…catch…finally

格式：

复制代码
1
2
3
4
5
6
7
try {
	可能出现问题的代码;
}catch(异常名 变量) {
	针对问题的处理;
}finally {
	释放资源;
}

代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package yichang01;
public class ExceptionDemo {
    public static void main(String[] args){
        System.out.println("start");
        int[] arr = {1,2,3,4,5};
        try {
            System.out.println(arr[5]);
        }catch (Exception e){
            System.out.println("发生了异常："+e.getMessage());
            e.printStackTrace();//打印异常的栈
        }finally {//有没有异常都会执行 finally 里的代码
            System.out.println("释放资源，必须执行的代码块");
        }
        //System.out.println(arr[5]);//数组下标越界
        System.out.println("end");
    }
}

变形格式：

复制代码
1
2
3
4
5
try {
 	可能出现问题的代码;
}catch(异常名 变量) {
	针对问题的处理;
}
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package yichang01;
public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("start");
        int a = 10;
        int b = 0;
        try {
            System.out.println(a / b);
        } catch (Exception e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

注意：

  • try 里面的代码越少越好
  • catch 里面必须有内容，哪怕给出一个简单的提示

四、try…catch 处理方式

1、一个异常的情况与多个异常的情况

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package yichang01;
public class ExceptionDemo {
    public static void main(String[] args) {
        //method1();//一个异常的情况
        //method2();//两个异常、分别处理的情况
        //method3();//两个异常、一块处理的情况
        method4();
    }
    private static void method4() {
        int a = 10;
        int b = 0;
        int[] arr = {1, 2, 3};
        try {
            Object o = 123;
            String s = (String) o; //ClassCastException
            System.out.println(arr[3]); //IndexOutOfBoundException
            System.out.println(a / b); //ArithmeticException
            System.out.println("这里出现了一个异常，你不太清楚是谁，该怎么办呢?");
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("你访问了不该的访问的索引");
        } catch (Exception e) {
            System.out.println("出问题了");
        }
        System.out.println("over");
    }
    private static void method3() {
        int a = 10;
        int b = 0;
        int[] arr = {1, 2, 3, 4, 5};
        try {
            System.out.println(a / b);
            System.out.println(arr[5]);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("索引越界");
        }
        System.out.println("end");
    }
    private static void method2() {
        int a = 10;
        int b = 0;
        try {
            System.out.println(a / b);
        } catch (Exception e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        System.out.println("end1");
        int[] arr = {1, 2, 3, 4};
        try {
            System.out.println(arr[4]);
        } catch (Exception e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        System.out.println("end2");
    }
    private static void method1() {
        int a = 10;
        int b = 0;
        try {
            System.out.println(a / b);
        } catch (Exception e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

五、Throwable中的方法

1、getMessage()

获取异常信息，返回字符串。

2、toString()

获取异常类名和异常信息，返回字符串。

3、printStackTrace()

获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

4、printStackTrace(PrintStream s)

通常用该方法将异常内容保存在日志文件中，以便查阅。

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package yichang01;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo {
    public static void main(String[] args) {
        String s = "2019-06-17";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date d = sdf.parse(s);
            System.out.println(d);
        } catch (ParseException e) {
            System.out.println(e.getMessage());
            System.out.println(e.toString());
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

六、throws

1、概述

定义功能方法时，需要把出现的问题暴露出来，让调用者去处理

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package yichang02;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo {
    public static void main(String[] args) throws ParseException {
        System.out.println("start");
        method1();
        System.out.println("end11");
        //method2();
        System.out.println("end22");
    }
    private static void method2() throws ArithmeticException {//运行期异常抛出
        int a = 10;
        int b = 0;
        System.out.println(a / b);
    }
    private static void method1() throws ParseException {//编译期异常抛出
        String s = "2014-11-20";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(s);
        System.out.println(d);
    }
}

七、throw

1、概述

在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，用 throw 把异常对象抛出

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package yichang02;
public class ExceptionDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setAge(-30);
    }
}
class Student {
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age > 1) {
            this.age = age;
        } else {
            try {
                throw new Exception("年龄不能小于1");//throw：方法内部，一般出现了逻辑错误，手动抛出的自定义异常
            } catch (Exception e) {
                e.printStackTrace();
            }
            this.age = 1;
        }
    }
}

八、throws和throw的区别

throws

  • 用在方法声明后，跟的是异常类名
  • 可以跟多个异常类名，用逗号隔开
  • 表示抛出异常，由该方法的调用者来处理
  • throws 表示出现异常的一种可能性，并不一定会发生这些异常

throw

  • 用在方法体内，跟的是异常对象名
  • 只能抛出一个异常对象名
  • 抛出异常，由方法体内的语句处理
  • throw 则是抛出了异常，执行 throw 则一定抛出了某种异常
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package yichang02;
class ExceptionDemo {
    public static void main(String[] args) {
        //method1();
        try {
            method2();
        } catch (Exception e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
    }
    private static void method2() throws Exception {
        int a = 10;
        int b = 0;
        if (b == 0) {
            throw new Exception();
        } else {
            System.out.println(a / b);
        }
    }
    private static void method1() {
        int a = 10;
        int b = 0;
        if (b == 0) {
            throw new ArithmeticException();
        } else {
            System.out.println(a / b);
        }
    }
}

九、try…catch…finally…

1、格式

复制代码
1
2
3
4
5
try...catch...finally
 try...catch
 try...catch...catch...
 try...catch...catch...finally
 try...finally

2、注意

被finally控制的语句体一定会执行

用于释放资源，在IO流操作和数据库操作中会见到

3、代码

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package yichang02;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
class ExceptionDemo {
    public static void main(String[] args) {
        String s = "2019-6-17 12:12:12";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = null;
        try {
            d = sdf.parse(s);
        } catch (ParseException e) {
            e.printStackTrace();
            System.exit(0);
        } finally {
            System.out.println("这是必然执行的代码");
        }
        System.out.println(d);
    }
}
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package yichang02;
class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println(getInt());
    }
    public static int getInt() {
        int a = 10;
        try {
            System.out.println(a / 0);
            a = 20;
            return a;
        } catch (Exception e) {
            System.out.println("catch");
            a = 30;
            return a;
        } finally {//释放资源，会执行的代码
            System.out.println("finally");
            a = 40;
            return a;
        }
        // return a;
    }
}

十、final , finally 和 finalize的区别

1、final：最终的意思，可以修饰类，成员变量，成员方法

  • 修饰类，类不能被继承
  • 修饰变量，变量是常量
  • 修饰方法，方法不能被重写

2、finally：是异常处理的一部分，用于释放资源。

  • 一般来说，代码肯定会执行，特殊情况：在执行到finally之前jvm退出了

3、finalize：是Object类的一个方法，用于垃圾回收

十一、异常注意事项

  • 子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了，儿子不能比父亲更坏)
  • 如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者是他的子集，子类不能抛出父类没有的异常
  • 如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，如果子类方法内有异常发生，那么子类只能try，不能throws

以上为个人经验，希望能给大家一个参考，也希望大家多多支持靠谱客。

最后

以上就是可耐睫毛膏最近收集整理的关于Java IO流—异常及捕获异常处理 try…catch…finally的全部内容，更多相关Java IO流—异常及捕获异常处理 try…catch…finally内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(141)

相关文章

使用BufferedReader读取TXT文件中数值,并输出最大值
使用BufferedReader读取TXT文件中数值,并输出最大值
如何利用Java输出链表中倒数第k个结点
如何利用Java输出链表中倒数第k个结点
基于bufferedreader的read()与readline()读取出错原因及解决
基于bufferedreader的read()与readline()读取出错原因及解决
java基础知识之FileInputStream流的使用
java基础知识之FileInputStream流的使用
Java IO流—异常及捕获异常处理 try…catch…finally
Java IO流—异常及捕获异常处理 try…catch…finally
Java读文件修改默认换行符的实现
Java读文件修改默认换行符的实现
使用FileReader采用的默认编码
使用FileReader采用的默认编码
新的Java访问mysql数据库工具类的操作代码
新的Java访问mysql数据库工具类的操作代码

评论列表共有 0 条评论

立即
投稿
返回
顶部