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在运行程序过程中出现的错误

Java IO流—异常及捕获异常处理 try…catch…finally_第1张图片

2、常见的异常

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

Java IO流—异常及捕获异常处理 try…catch…finally_第2张图片

3、异常的分类

Java IO流—异常及捕获异常处理 try…catch…finally_第3张图片

Java IO流—异常及捕获异常处理 try…catch…finally_第4张图片

三、异常处理方案

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

Java IO流—异常及捕获异常处理 try…catch…finally_第5张图片

变形格式:

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

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

Java IO流—异常及捕获异常处理 try…catch…finally_第6张图片

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)