「Java」九、异常处理

发布于 2022-03-31  198 次阅读


异常概述与异常体系结构

异常概述

在使用计算机语言进行项目开发的过程中,即使程序员把代码写得尽善尽美, 在系统的运行过程中仍然会遇到一些问题,因为很多问题不是靠代码能够避 免的,比如:客户输入数据的格式,读取文件是否存在,网络是否始终保持 通畅等等。

异常:在Java语言中,将程序执行中发生的不正常情况称为“异常” 。 (开发过程中的语法错误和逻辑错误不是异常)

Java程序在执行过程中所发生的异常事件可分为两类:

Error(错误):Java虚拟机无法解决的严重问题。如:JVM系统内部错误、资源耗尽等严重情况。比如:StackOverflowError和OOM。一般不编写针对性的代码进行处理。

public class ErrorTest{
    public static void main(String[] args){
        //1.栈溢出:java.lang.StackOverflowError
        main(args);
        //2.堆溢出:java.lang.OutOfMemoryError
        Integer[] arr=new Integer[1024*1024*1024];
    }
}

Exception(狭义的异常):其它因编程错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行处理。例如: 空指针访问,试图读取不存在的文件,网络连接中断,数组角标越界

对于这些错误,一般有两种解决方法:一是遇到错误就终止程序的运行。另一种方法是由程序员在编写程序时,就考虑到错误的检测、错误消息的提示,以及错误的处理。

捕获错误最理想的是在编译期间,但有的错误只有在运行时才会发生。 比如:除数为0,数组下标越界等 ->分类:编译时异常运行时异常

异常体系结构

编译时异常:执行javac.exe命令时,可能出现的异常

运行时异常:执行java.exe命令时,可能出现的异常

红色:受检(checked)异常

蓝色:非受检(unchecked)异常

image-20220330092245055

1.运行时异常:是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误,是程序员应该积极避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常。
对于这类异常,可以不作处理,因为这类异常很普遍,若全处理可能会对 程序的可读性和运行效率产生影响。
2.编译时异常:是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。
对于这类异常,如果程序不处理,可能会带来意想不到的结果。

java.lang.Throwable
        |-----java.lang.Error:一般不便携针对性的代码进行处理
        |-----java.lang.Exception:可以进行异常处理
                     |-----编译时异常(checked)
                                  |-----IOException
                                               |-----FileNotFoundException
                                  |-----CLassNotFoundException
                     |-----运行时异常(unchecked)
                                  |-----NullPointerException
                                  |-----ArrayIndexOutOfBoundsException
                                  |-----ClassCastException
                                  |-----NumberFormatException
                                  |-----InputMismatchException
                                  |-----ArithmeticException

常见异常

运行时异常:

NullPointerException

public class NullRef {
    int i = 1;
    public static void main(String[] args) {
        NullRef t = new NullRef();
        t = null;
        System.out.println(t.i);
    }
}

ArrayIndexOutOfBoundsException

public class EceptionTest{
    @Test
    public void test2(){
        int[] arr=new int[10];
        System.out.println(arr[10]);
    }
}

StringIndexOutOfBoundsException

public class EceptionTest{
    @Test
    public void test2(){
        String str="abc";
        System.out.println(str.charAt(3));
    }
}

ClassCastException

public class EceptionTest{
    @Test
    public void test3(){
        Object obj=new Date();
        String str=(String)obj;
    }
}

NumberFormatException

public class EceptionTest{
    @Test
    public void test4(){
        String str="123";
        str="abc";
        int num=Integer.parseInt(str);
    }
}

InputMismatchException

public class EceptionTest{
    @Test
    public void test5(){
        Scanner scanner=new Scanner(System.in);
        int score=scanner.nextInt();
        System.out.println(score);
    }
}

ArithmeticException

public class EceptionTest{
    @Test
    public void test6(){
        int a=10;
        int b=0;
        System.out.println(a/b);
    }
}

编译时异常FileNotFoundException,IOException e

public class EceptionTest{
    @Test
    public void test7(){
        File file=new File("hello.txt");
        fis=new FileInputStream(file);

        int data=fis.read();
        while(data!=-1){
            System.out.print((char)data);
            data=fis.read();
        }

        fis.close();
    }
}

异常处理机制一: try-catch-finally

一、异常的处理:抓抛模型

过程一:“抛”:程序在正常执行的过程中,一旦出现异常,就会在异常代码处生成一个对应异常类的对象。并将此对象抛出。一旦抛出对象后,其后的代码就不再执行。

关于异常对象的产生:①系统自动生成的异常对象,②手动的生成一个异常对象,并抛出(throw)

过程二:“抓”:可以理解为异常的处理方式:①try-catch-finnally,②throws

二、try-catch-finally的使用

格式:

try{
    //课程出现异常的代码
}catch(异常类型1 变量名1){
    //处理异常的方式1
}catch(异常类型2 变量名2){
    //处理异常的方式2
}catch(异常类型3 变量名3){
    //处理异常的方式3
}finally{
    //一定会执行的代码
}

两种常用的报错方式:

try{

}catch(Exception e){
    System.out.println(e.getMessage());
    e.printStackTrace();
}

体会1:使用try-catch-finally处理编译时异常,使得程序在编译时就不再报错,但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常,延迟到运行时出现。

体会2:开发中,由于运行时异常比较常见,所以我们通常就不针对运行时异常编写try-catch-finally,针对编译时异常,我们一定要考虑异常处理。

RuntimeException类或是它的子类,即使没有使用try和catch捕获,Java自己也能捕获,并且编译通过。非运行时异常,则必须捕获,否则编译错误。也就是说,我们必须处理编译时异常,将异常进行捕捉,转化为运行时异常。

说明:

  1. finally是可选的
  2. finally中声明的是一定会被执行的代码。即使“catch中又出现异常了,try中又return语句,catch中又return”等情况。即,finally=="等等!我先执行"
  3. 一旦try中的异常对象匹配到某一个catch时,就进入catch中进行异常的处理。一旦处理完成,就跳出当前的try-catch结构(在没有写finally的情况),继续执行其后的代码
  4. catch中的异常类型如果没有子父类关系,则声明无论先后;否则要求子类一定声明在父类上面,不然会报错
  5. 常用的异常对象处理的方式:①String getMessage(),②printStackTrace()
  6. 在try结构中声明的变量,出了try结构以后,就不能再被调用
  7. try-catch-finally结构可以嵌套

可以用选中代码快->右键->Surround With->Try/catch Block,自动生成。

image-20220331093329123

finally的再说明:

  1. finally是可选的
  2. finally中声明的是一定会被执行的代码
  3. 像数据库连接、输入输出流、网络编程Socket等资源,JVM是不能自动回收的,我们需要自己手动的进行资源的释放。此时的资源释放,就需要声明在finally中
public void test2(){
    FileInputStream fis=null;
    try{
        File file=new File("hello.txt");
        fis=new FileInputStream(file);

        int data=fis.read();
        while(data!=-1){
            System.out.print((char)data);
            data=fis.read();
        }
    }catch(FileNotFoundException e){
        e.printStackTrace();
    }catch(IOException e){
        e.printStackTrace();
    }finally{
        try{
            if(fis!=null)
                fis.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

hello.txt在当前的工程下。在工程下创建文件(先别写中文,因为字节流读不了字符)

异常处理机制二: throws

  1. “throws + 异常类型“写在方法的声明处。指明此方法执行时,可能会抛出的异常类型。
    一旦当方法被执行时,出现异常,仍会在异常代码处生成一个异常类的对象,此对象满足throws后异常类型时,就会被抛出。异常代码后续的代码,就不再执行。
  2. 对比两种处理方式:try-catch-finally:真正的把异常处理掉了。throws的方式只是将异常抛给了方法的调用者,并没有真正的将异常处理掉。
    ps.子父类抛出的异常大小关系:子类重写的方法抛出的异常类型不大于父类
  3. 开发中如何选择使用try-catch-finally和throws?
    3.1 如果父类中被重写的方法没有throws方式处理异常,则子类重写的方法也不能使用throws,意味着如果子类重写的方法中有异常,必须使用try-catch-finally方式处理
    3.2 执行的方法a中,先后调用了另外的几个方法,这几个方法是递进关系执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理

手动抛出异常

Java异常类对象,除在程序执行过程中出现异常时由系统自动生成并抛出,也可根据需要使用人工创建并抛出。(throw)

throw和throws区别:

throw表示抛出一个异常类的对象,生成异常对象的过程。声明在方法体内。

throws属于异常处理的一种方式,声明在方法的声明处。

public class StudentTest{
    public static void main(String[] args){
        try{
            Student s=new Student();
            s.regist(-1001);
            System.out.println(s);
        }catch(Exception e){
            System.out.prinln(e.getMessage());
        }
    }
}
class Student{
    private int id;
    public void regist(int id) throws Exception{
        if(id>0){
            this.id=id;
        }else{
            throw new Exception("您输入的数据非法");
        }
    }
}

用户自定义异常类

如何自定义异常类?

  1. 继承于现有的异常结构:RunTimeExcption、Exception
  2. 提供全局常量:serialVersionUID
  3. 提供重载的构造器
public class MyException extends RuntimeException{

    static final long serialVersionUID = -9271957429329742L;

    public MyException(){

    }

    public MyException(String message){
        super(message);
    }
}

class Student{
    private int id;
    public void regist(int id) throws Exception{
        if(id>0){
            this.id=id;
        }else{
            throw new MyException("您输入的数据非法");//抛出自定义的异常类型
        }
    }
}

练习:

public class EcmDef{
    public sataic void main(String[] args){
        try{
            int i=Integer.parseInt(args[0]);
            int j=Integer.parseInt(args[1]);

            int result=ecm(i,j);

            System.out.prinln(result);
        }catch(NumberFormatException e){
            System.out.prinln("数据类型不一致");
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.prinln("缺少命令行参数");
        }catch(ArithmeticException e){
            System.out.prinln("除0");
        }catch(EcDef e){
            System.out.prinln(e.getMessage());
        }
    }
    public static int ecm(int i,int j) throws EcDef{
        if(i<0||j<0){
            throw new EcDef("分子或分母为负数了");
        }
        return(i/j);
    }
}
//自定义异常类
public class EcDef extends Exception{
    static final long serialVersionUID = -32285492089542L;
    public EcDef(){

    }
    public EcDef(String msg){
        super(msg);
    }
}

面试题总结:

类似型:

  • final、finally、finalize
  • throw、throws
  • Collection、Collections
  • String、StringBuffer、StringBuilder
  • ArrayList、LinkedList
  • HashMap、LinkedHashMap
  • 重写、重载

结构不相似的:

  • 抽象类、接口
  • ==、equals()
  • sleep()、wait()