java基础（8）- java的异常处理

ImportNewXXT0101

已于 2023-09-08 00:06:25 修改

阅读量313

点赞数

分类专栏：【基础要牢靠】Java核心基础文章标签： java

于 2017-12-05 10:41:21 首次发布

本文链接：https://blog.csdn.net/m0_37955444/article/details/78716931

版权

【基础要牢靠】Java核心基础专栏收录该内容

28 篇文章 2 订阅

订阅专栏

8.1异常的基本概念和处理流程

8.2各种常见的异常

8.3异常的嵌套和级联

8.4自定义异常和throw、throws的使用

自定义异常和throw、throws的使用。

8.1异常的基本概念和处理流程

一、异常的基本概念

在java中把导致程序中断运行的情况分为两种，一种就是异常，而另外一种叫做错误。所有异常的基类是Exception，错误的基类是Error。Exception是在java程序中可以编码进行控制的，具有可编程性，而Error是指Java运行时系统来显示与运行时系统本身有关的错误，Error对于程序员来说是灾难性的，程序无法控制，比如jvm堆栈溢出错误，操作系统分配内存错误等。不管是Exception还是Error，他们的共同父类是java.lang.Throwable(可抛出的) 类。

异常是指在程序运行期可能出现的非正常情况，这些情况将导致程序出错，这种出错不同于代码编写错误或程序算法出错，代码编写错误无法完成编译，而程序算法出错计算将取得错误的结果。程序出现异常时，缺省会直接造成程序的中断运行，提前预知这种异常的可能性可以补充异常处理的逻辑，从这个角度出发，异常也是一种行之有效的逻辑处理机制，在程序中声明异常或主动抛出异常也很常见。

简而言之，为了提高程序的健壮性，异常需要由程序员处理。

二、异常的作用和处理流程

1、什么时候需要捕获异常

我们先看看下面的代码：

public class Cal {
    public int div(int a, int b) {
        int result = a / b;
        return result;
    }
    public static void main(String[] args) {
        Cal cal=new Cal();
        int result=cal.div(10, 2);
        System.out.println("结果："+result);
    }
}

在这里我们设计了Cal类和它的div方法，用于计算两个数的商，在main方法中我们调用这个方法，可以正常的输出：结果：5；但是如果用户用下面的代码调用（注意：除数为0。）

public static void main(String[] args) {
        Cal cal=new Cal();
        int result=cal.div(10, 0);
        System.out.println("结果："+result);
    }

程序的语法是没有问题的，但是程序确没有能正常显示结果，控制台输出如下：

程序因为异常而终止，导致程序并没有输出，这个异常应该由程序员显示捕获，以调程序的健壮性。

2、处理流程和关键字介绍

异常处理主要使用的关键字是：try、catch、finaly、throw、throws。其功能如下所示：

由上图可知try、catch、finally常常组合使用，finally是可选的，但是try和catch必须一起使用。其执行流程如下图所示：

具体语法格式是：

try{

可能出现异常的代码

}catch(异常类对象){

出现异常后的处理，如果没有出现异常，这里是不会进入的。

}finally{

不管有没有异常都会在最后执行的代码。

}

那么修改上面的main方法。先看看没有异常时候的输出。代码如下：

public static void main(String[] args) {
        Cal cal=new Cal();
        try{
            int result=cal.div(10, 2);
            System.out.println("结果："+result);
        }catch (Exception e) {
            System.out.println("发生异常了。");
        }finally{
            System.out.println("结束。");
        }
        
}

程序并没有发生异常，所以catch的后面的语句块没有进入了，控制台输出如下图：

修改一下main方法，使除数为0。

public static void main(String[] args) {
        Cal cal=new Cal();
        try{
            int result=cal.div(10, 0);//这一句发生了异常，后面的代码就不会
            System.out.println("结果："+result);//这句没有执行
        }catch (Exception e) {
            System.out.println("发生异常了。");//进入了异常处理
        }finally{
            System.out.println("结束。");//这句还是会执行
        }
        
}

控制台输出如下图：

8.2各种常见的异常

各种常见的异常

一、各种常见的异常

在上一节中程序如果你注意留意，程序抛出的异常是：java.lang.ArithmeticException。这个异常是在lang包中已经定义的。在lang包中还定义了一些我们非常常见的异常，如下表：

上面这些异常要求都能记住，程序抛出了异常后，你要知道程序发生了是什么问题。我们可以举个例子说明一下。代码如下：

public static void main(String[] args) {
        Cal cal=null;//没有new对象
        try{
            int result=cal.div(10, 0);//这里会抛出空指针异常
            System.out.println("结果："+result);//这句没有执行
        }catch (Exception e) {
            e.printStackTrace();//可以使用printStackTrace方法打印异常信息。
        }
    }

finally语句块不是必须的，所以我们并没有finally语句块，我们通过异常的printStackTrace方法打印异常信息，所以控制台最后输入：

再比如一下例子：

public static void main(String[] args) {
        int []arr={1,2,3,4};
        try{
            System.out.println(arr[5]);//数组越界
        }catch (Exception e) {
            e.printStackTrace();//可以使用printStackTrace方法打印异常信息。
        }
}

控制台输出数组越界异常。如图：

二、异常直接的继承关系

异常类之间的继承关系如下图：

对上图我们需要说明几点

1、Throwable类有两个直接子类：一个是Error类，一个是Exception类。Error类前面我们也讲过了，是java程序运行时系统的内部错误，例如内存溢出等，这点不需要我们程序员关心，关心了也没有什么办法的。我们需要关系的Exception。他表示程序运行是的错误，可以使用try...catch...捕获。

2、系统定义的异常大部分都是继承了RuntimeException，有类名可知，就是运行时异常，上面我们介绍的的空指针异常，除数为0异常，和数据越界异常都是它的子类。

8.3异常的嵌套和级联

异常的嵌套和级联

这节我们需要探讨的问题是，如果我们需要try尝试捕获的异常不止一个，那么我们需要如何处理呢？

一、分开捕获或者嵌套使用

我们先看看下面这段代码：

public class Cal {

    public int div(int a, int b) {
        int result = a / b;
        return result;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int s = 0;

        int num1 = 0;
        int num2 = 0;

        //1、这里可能会抛出异常
        System.out.print("num1=");
        num1 = scanner.nextInt();
        System.out.print("num2=");
        num2 = scanner.nextInt();

        Cal cal = new Cal();
        //2、这里也可能抛出异常
        s = cal.div(num1, num2);

        System.out.println(s);
    }
}

在这段代码中有可能抛出异常的有两个地方，那么我们应该如何处理呢。

1、当然我们可以分开捕获。如下面的代码：

public class Cal {

    public int div(int a, int b) {
        int result = a / b;
        return result;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int s = 0;

        int num1 = 0;
        int num2 = 0;
              //1、这里可能会抛出异常
        try {
            
            System.out.print("num1=");
            num1 = scanner.nextInt();
            System.out.print("num2=");
            num2 = scanner.nextInt();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        Cal cal = new Cal();
                //2、这里也可能抛出异常
        try {
            s = cal.div(num1, num2);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println(s);
    }
}

2、我们还可以在try里面嵌套的使用try语句。如下面代码所示：

public class Cal {

    public int div(int a, int b) {
        int result = a / b;
        return result;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int s = 0;

        int num1 = 0;
        int num2 = 0;

        try {
            //1、这里可能会抛出异常
            System.out.print("num1=");
            num1 = scanner.nextInt();
            System.out.print("num2=");
            num2 = scanner.nextInt();
            
            try {
                Cal cal = new Cal();
                //2、这里也可能抛出异常
                s = cal.div(num1, num2);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        

        System.out.println(s);
    }
}

二、使用级联捕获异常

上面介绍的这两种方法都不是好办法，以为过多的使用try捕获异常会影响程序的效率。所以我们推荐使用的是级联捕获异常。格式如下

try{

…...

}catch(ArrayIndexOutOfBoundsException e) {

……

} catch(ArithmeticException e) {

……

} catch(Exception e) {

……

}

注意：使用多重 catch 语句时，异常子类一定要位于异常父类之前。

所以以下这种方式是错误的。

try{

…...

} catch(Exception e) {

……

} catch(ArrayIndexOutOfBoundsException e) {

……

}

好，那么我们可以修改上面的代码如下：

public class Cal {
    public int div(int a, int b) {
        int result = a / b;
        return result;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int s = 0;

        int num1 = 0;
        int num2 = 0;
        try {
            //1、这里可能会抛出异常
            System.out.print("num1=");
            num1 = scanner.nextInt();
            System.out.print("num2=");
            num2 = scanner.nextInt();

            Cal cal = new Cal();
            //2、这里也可能抛出异常
            s = cal.div(num1, num2);
        } catch (ArithmeticException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (InputMismatchException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(s);
    }
}

由于多次的使用try或影响效率。所以我们如果碰到循环的时候，应该把try语句放到循环的外面，例如我们并不推荐你这样写代码：

public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4 };
        Cal cal = new Cal();

        for (int i = 0; i < arr.length; i++) {
            try {
                int s = cal.div(arr[i], 2);
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    }

你可以修改成为这样：

    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4 };
        Cal cal = new Cal();
        try {
            for (int i = 0; i < arr.length; i++) {
                int s = cal.div(arr[i], 2);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
    }

8.4自定义异常和throw、throws的使用

自定义异常和throw、throws的使用。

一、自定义异常类

我们知道所有的异常都是Exception，所以我们需要自定义异常只需要继承那个Exception类就可以了。下面我们自定义一个异常类，代码如下：

/**
 * 自定义异常，
 */
//继承  Exception
public class MyException  extends Exception{
    public MyException(String message){
        //出现异常打印的语句
        super(message);
    }
}

二、设计方法，抛出异常

下面我们可以设计一个方法，抛出异常，代码如下：

public class Student {
                           //显示抛出异常 ，可以同时抛出多个,
                          //那么，调用此方法的就必须捕获此异常或者继续抛出
    public void stu(int age) throws MyException,ArithmeticException{
        if(age<18){
            throw new MyException("靓仔，你年龄不够");
        }
        System.out.println("欢迎，报名！");
    }
}

注意抛出异常的格式是在方法后面使用throws关键字，可以抛出多个异常使用英文逗号隔开即可。在程序里面我们要求年龄必须是大于18，否则就显示的抛出异常，在这里使用的关键字是throw。抛出我们刚才新建的异常类对象。

三、测试方法

我们在main方法中调用这个方法。由于我们设计的这个方法抛出了异常。所有我们在调用的时候编译器要求我们必须处理异常。我们有两种处理方法

1、使用try...catch...捕获异常

由于方法抛出了两个异常所以我们两个都需要捕获。代码如下：

public class Run {
    public static void main(String[] args) {
        Student student = new Student();
        try {
            student.stu(18);
        } catch (ArithmeticException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (MyException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2、在调用的方法使用throws继续抛出异常。

我们也需要抛出两个异常。代码如下：

public class Run {
    public static void main(String[] args) throws ArithmeticException,
            MyException {
        Student student = new Student();
        student.stu(18);
    }
}