Java异常处理机制

Java异常处理机制

 

一、异常简介

异常就是程序在运行时出现不正常情况

异常类：是对问题的描述，将问题进行对象的封装

异常的由来：问题也是现实生活中一个具体事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。

Throwable：所有错误或异常的父类（超类） 

|--Error

|--Exception                      

   |--RuntimeException

对于问题的划分为两种：

【1】Error---严重问题（无法处理）

对于严重的（无法处理），java通过Error类进行描述

对于Error一般不编写针对性的代码对其进行处理

【2】Exception---非严重问题（可以处理）

对与非严重的（可以处理），java通过Exception类进行描述

总结：无论Error或者Exception都具有一些共性内容，比如：不正常情况的信息，引发原因等

• 异常处理

【1】一般异常出现，Java进行识别，调用封装的异常处理，要么在main函数throws抛出去，要么try---catch处理

【2】其实jvm默认的异常处理机制，就是在调用printStackTrace方法，打印异常的堆栈的跟踪信息

【3】一般情况异常处理都不用打印错误，而是用日志记录系统错误

Java提供了特有的语句进行处理

(try:检测错误, catch：捕捉错误)

try{

     需要被检测的代码;

    }

    catch(异常类 变量){

     处理异常的代码；（处理方式）

    }

    finally{

     一定会执行的语句;

    }

 

class Dome{

//在功能通过throws的关键字声明了该功能可能有问题（抛出异常）

//当值传入运行出现异常，java识别异常便自动抛出给jvm处理

    int div(int x,int y)throws Exception

{

        return x/y;

    }

}

try{

Dome d=new Dome();

//【1】程序执行try检测函数的异常类型，便new ArithmeticException()

             int x=d.div(4,0);

             System.out.println("除零"+x);

            }

//【2】相当于Exception e=new ArithmeticException();

            catch(Exception e){

             System.out.println("除零啦");

//【3】获取字符串类型的错误信息  / by zero

             System.out.println(e.getMessage());

//【4】获取异常名称：异常信息  

java.lang.ArithmeticException: / by zero

             System.out.println(e.toString());

//【5】异常名称，异常信息，异常出现的位置

//其实jvm默认的异常处理机制，就是在调用printStackTrace方法，打印异常的堆栈的跟踪信息

             e.printStackTrace();

            }

三、对多异常的处理

【1】声明异常时，建议声明更为具体的异常。这样处理的可以更具体

【2】对方声明几个异常，就对应有几个catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

【3】建议在进行catch处理时，catch中一定要定义具体处理方式，不要简单定义一句e.printStackTrace()，也不要简单就书写一条输出语句。

class Dome{

    //在功能通过throws的关键字声明了该功能可能有问题

//当值传入运行出现异常，java识别异常便自动抛出给jvm处理

    int div(int x,int y)throws ArithmeticException,ArrayIndexOutOfBoundsException

    {

        int[] arr=new int[x];

        System.out.println(arr[4]);

        return x/y;

    }

}

try{

            Dome d=new Dome();

             int x=d.div(4,0);

             System.out.println("除零"+x);

            }

        //相当于Exception e=new ArithmeticException();

            catch(ArithmeticException e){

             System.out.println(e.toString());

            }

//相当于Exception e=new ArrayIndexOutOfBoundsException();

           catch(ArrayIndexOutOfBoundsException e){

             System.out.println(e.toString());

            }

 

四、自定义异常

因为项目中会出现特有的问题，而这些问题并未被java所描述并封装，,所以对于这些特有的问题可以按照java的对问题的封装的思想，将特有的问题，进行自定义的异常封装。

【1】特有异常，java无法识别，无法自动抛出给jvm处理。只能进行自定义的异常封装，手动抛出问题

1. 自定义异常封装是为了可以创建对象，给有问题的函数声明具体的异常。

//进行自定义的异常封装

class FushuException extends Exception{

   

}

1. 发现打印结果中只有异常名称，没有异常的信息，因为自定义的异常并未定义信息。

（要自定义异常信息时，可以使用父类已经定义好的功能，异常信息传递给父类的构造函数super(msg);）

//【1】进行自定义的异常封装

class FushuException extends Exception{

//【2】子类只要在构造时，将异常信息传递给父类

    FushuException(String msg){

//【3】通过super语句将参数传给父类已有的异常处理的方法

//【4】那么可以直接通过getMessage()方法获取自定义异常信息

        super(msg);

    }

}

父类已有的定义异常信息方法：

1. 也可以自定义异常信息（和父类的已有方法一样）

//【1】进行自定义的异常封装

class FushuException extends Exception{

private String msg;

    FushuException(String msg){

        this.msg=msg;

    }

    public String getMessage() {

        return msg;

    }

}

 

【2】当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理要么在main函数上声明让调用者处理。

一般情况下，函数内出现异常，函数上需要声明。

//进行自定义的异常封装

class FushuException extends Exception{

    FushuException(String msg){

//通过super语句将参数传给父类已有的异常处理的方法getMessage()     super(msg);

    }

}

class Dome{

    //函数类有问题，函数就得声明出来

    int div(int x,int y) throws FushuException

    {

        //手动通过throw关键字抛出一个自定义异常对象

        if(y<0) throw new FushuException();

        {

        }

        return x/y;

    }

}

try{

            Dome d=new Dome();

             int x=d.div(4,-1);

             System.out.println("除零"+x);

            }

            catch(FushuException e){

             System.out.println(e.toString());

             System.out.println("除数出现负数啦！！");

             

            }

 

注意自定义异常：必须是自定义类继承Exception

【1】一般看情况函数内抛throw，那么就必须声明函数外抛throws

【2】如果函数声明了异常那么主函数main（调用者）要么继续throws抛出，要么try---catch捕捉异常

【3】注意RuntimeException除外，也就是说函数内如果抛出RuntimeException异常，函数上可以不用声明

继承Exception原因

异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性，这个可抛性是Throwable这个体系中独有特点。只有这个体系的类和对象才可以被throws和throw操作

-----------------------------------------------------------------------------

throws和throw的区别

1、注意throws和throw都是结束程序的语句，不会再执行下方的代码，与return一样。

2、如果有finally语句，就一定还会执行finally语句

3、System.exit(0);系统退出，jvm结束。因为jvm结束，会退出程序，便不会再执行finally语句

 

【1】throws使用在函数上

throws后面跟的异常类，可以跟多个。用逗号隔开。

【2】throw使用在函数内

throw后跟的是异常对象