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

Z时代
2024-01-10
分类：IT

一、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

格式：


try {
	可能出现问题的代码;
}catch(异常名 变量) {
	针对问题的处理;
}finally {
	释放资源;
}

代码：


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");
    }
}

在这里插入图片描述

变形格式：


try {
 	可能出现问题的代码;
}catch(异常名 变量) {
	针对问题的处理;
}


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、一个异常的情况与多个异常的情况


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)

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


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、概述

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

在这里插入图片描述


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 把异常对象抛出


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 则一定抛出了某种异常


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、格式

try...catch...finally

try...catch

try...catch...catch...

try...catch...catch...finally

try...finally

2、注意

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

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

3、代码


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);
    }
}


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 的全部内容，来源链接： utcz.com/p/251409.html

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

目录

一、Java IO流

1、概念

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

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

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

二、Java 异常

1、概述

2、常见的异常

3、异常的分类

三、异常处理方案

1、try…catch…finally

四、try…catch 处理方式

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

五、Throwable中的方法

1、getMessage()

2、toString()

3、printStackTrace()

4、printStackTrace(PrintStream s)

六、throws

1、概述

七、throw

1、概述

八、throws和throw的区别

九、try…catch…finally…

1、格式

2、注意

3、代码

十、final , finally 和 finalize的区别

十一、异常注意事项

其他人也看了：

Nginx防盗链的配置方法

nginx内存池源码解析

shell脚本之nginx自动化脚本

Nginx优化配置和内核优化 实现突破十万并发

nginx,apache的alias和认证功能

关于nginx+php5.3.8+eclipse3.7工作空间的配置方法

Nginx优化配置和内核优化实现突破十万并发