Java基础_学习笔记_14_异常

class Test
{
    public int devide(int x,int y)
    {
        int result=x/y;
        return result;
    }
}
class TestException
{
    public static void main(String [] args)
    {
        Test t=new Test();
        t.devide(2,0);
        System.out.println("the program is running here!");
    }
}
/*
F:\java_example\lesson61>java TestException
Exception in thread "main" java.lang.ArithmeticException: / by zero
        at Test.devide(Test.java:5)
        at TestException.main(Test.java:14)
*/

上述代码中，由于除数为零，导致程序崩溃，后面的代码都不能执行。在实际工作中，或多或少会有各种异常出现，为了尽量避免，需要引入异常的处理机制。

经过异常处理之后，代码如下

class Test
{
    public int divide(int x,int y)
    {
        int result=x/y;
        return result;
    }
}
class TestException
{
    public static void main(String [] args)
    {
        Test t=new Test();
        try{
            t.divide(2,0);
　　　　　　　　　System.out.println("the divide opration is over");
        }
        catch(Exception e)
        {
            System.out.println(e.getMessage());
        }
        System.out.println("the program is running here!");
    }
}
/*
F:\java_example\lesson61>java TestException
/ by zero
the program is running here!
*/

在上述代码中，try的部分写入可能会发生异常的代码，异常发生后会直接转向执行catch部分代码，try中异常语句后面的代码会被忽略，如程序中的System.out.println("the devide operation is over！")；语句不会被执行。整个执行流程是当try中的语句发生异常，程序会调用catch，执行完catch中的程序之后，系统会继续执行catch代码块后的其他代码。

当try代码块中的程序发生异常，系统将这个异常发生的代码行号、类别等信息封装到一个对象中，并将该对象传递给catch代码块。catch关键字后跟有一个Exception类型的参数e，这跟我们经常用到的，如何定义一个函数接收的参数格式是一样的。括号中的Exception就是try代码块传递给catch代码块的变量类型，e是变量名，也可以换成别的名称。

如果我们将catch中不写任何语句，是空的，那么当try中代码发生异常后，不会打印出任何异常信息，而很难让人觉察到程序的错误，所以这一步不能偷懒。

throws关键字

在实际工作中，代码不止是一个人编写的，前一个人编写了一个函数，另一个人需要调用，如果这个函数在调用过程中会发生异常，但是后面的人不知道，那么一场就很可能会发生并导致程序崩溃，那么我们就引入了throws关键字。写devide方法的人需要在定义该方法时加上throws 关键字，调用者在调用该方法时，加上try...catch语句进行处理。若只用throws声明，哪怕函数是正确被调用，没有写try...catch则程序编译无法通过，如下：

class Test
{
    public int divide(int x,int y) throws Exception
    {
        int result=x/y;
        return result;
    }
}
class TestException
{
    public static void main(String [] args)
    {
        Test t=new Test();
        //try{
            t.divide(2,1);
            System.out.println("the divide opration is over");
        //}
        /*catch(Exception e)
        {
            System.out.println(e.getMessage());
        }*/
        System.out.println("the program is running here!");
    }
}
/*
F:\java_example\lesson61>javac Test.java
Test.java:15: 错误: 未报告的异常错误Exception; 必须对其进行捕获或声明以便抛出
                        t.devide(2,1);
                                ^
1 个错误
*/

将注释去掉之后，程序即可运行成功。

自定义异常与throw关键字

Exception类是java.lang.Throwable类的子类，Exception类继承了Throwable类的所有方法，在实际应用中，是使用Exception的子类来描述任何特定的异常。Exception类是所有异常类的父类，java中提供了常见的异常，比如：

ArithmeticException 在算术运算中发生的异常，如除数为零；

NullPointerException 空指针异常

ArrayIndexOutOfBoundsException 访问数组对象中存在的元素

除了系统定义的异常，我们也可以自己定义异常类，自定义的异常类必须继承Exception类

class Test
{
    public int devide(int x,int y) throws Exception
    {
        if(y<0)
            throw new DevideByMinusException("the divisor is negative "+y);
        //这里抛出的异常对象，就是catch(Exception e)中的e
        int result=x/y;
        return result;
    }
}
class DevideByMinusException extends Exception
{
    public DevideByMinusException(String msg)
    {
        super(msg);
    }
}
class TestException
{
    public static void main(String [] args)
    {
        Test t=new Test();
        try{
            t.devide(2,-1);
            System.out.println("the devide opration is over");
        }
        catch(Exception e)
        {
            System.out.println(e.getMessage());//打印出the divisor is negative -1
            e.printStackTrace();
        }
        System.out.println("the program is running here!");
    }
}
/*
F:\java_example\lesson61>java TestException
the divisor is negative -1
DevideByMinusException: the divisor is negative -1
        at Test.devide(Test.java:6)
        at TestException.main(Test.java:25)
the program is running here!
*/

java通过throw关键字抛出异常对象，语法格式是：

throw 异常对象；

一个try后面可以有多个catch，try中语句出现了哪种异常，就去执行对应的catch

class Test
{
    public int divide(int x,int y) throws ArithmeticException,DivideByMinusException
    {
        if(y<0)
            throw new DivideByMinusException("the divisor is negative "+y);
        //这里抛出的异常对象，就是catch(Exception e)中的e
        int result=x/y;
        return result;
    }
}
class DivideByMinusException extends Exception
{
    public DivideByMinusException(String msg)
    {
        super(msg);
    }
}
class TestException
{
    public static void main(String [] args)
    {
        Test t=new Test();
        try{
            t.divide(2,1);
            System.out.println("the divide opration is over");
        }
        catch(ArithmeticException e)
        {
            System.out.println("Error ~ ArithmeticException");
            e.printStackTrace();//Exception类中的方法
        }
        catch(DivideByMinusException e)
        {
            System.out.println("Error ~ DivideByMinusException");
            e.printStackTrace();
        }
        catch(Exception e)
        {
            System.out.println(e.getMessage());//打印出the divisor is negative -1
            e.printStackTrace();
        }
        System.out.println("the program is running here!");
    }
}
/*
F:\java_example\lesson61>java TestException
Error ~ DivideByMinusException
DivideByMinusException: the divisor is negative -1
        at Test.divide(Test.java:6)
        at TestException.main(Test.java:25)
the program is running here!
*/

上述代码，若没有发生异常就不进入任何catch，如果try中语句发生了异常，且该异常没有对应的catch，那么它就会执行Exception的catch，也就是我们代码中最后一个catch，因为所有的异常都是Exception的子类。也正因为如此，我们Exception对应的catch只能放在最后，如果不是放在最后，则程序编译错误，如下所示

class Test
{
    public int divide(int x,int y) throws ArithmeticException,DivideByMinusException
    {
        if(y<0)
            throw new DivideByMinusException("the divisor is negative "+y);
        //这里抛出的异常对象，就是catch(Exception e)中的e
        int result=x/y;
        return result;
    }
}
class DivideByMinusException extends Exception
{
    public DivideByMinusException(String msg)
    {
        super(msg);
    }
}
class TestException
{
    public static void main(String [] args)
    {
        Test t=new Test();
        try{
            t.divide(2,1);
            System.out.println("the divide opration is over");
        }
        catch(Exception e)
        {
            System.out.println(e.getMessage());//打印出the divisor is negative -1
            e.printStackTrace();
        }
        catch(ArithmeticException e)
        {
            System.out.println("Error ~ ArithmeticException");
            e.printStackTrace();//Exception类中的方法
        }
        
        catch(DivideByMinusException e)
        {
            System.out.println("Error ~ DivideByMinusException");
            e.printStackTrace();
        }
        /*catch(Exception e)
        {
            System.out.println(e.getMessage());//打印出the divisor is negative -1
            e.printStackTrace();
        }*/
        System.out.println("the program is running here!");
    }
}
/*
F:\java_example\lesson61>javac Test.java
Test.java:33: 错误: 已捕获到异常错误ArithmeticException
                catch(ArithmeticException e)
                ^
Test.java:39: 错误: 已捕获到异常错误DivideByMinusException
                catch(DivideByMinusException e)
                ^
2 个错误
*/

在实际应用中，我们可以通过try...catch来实现程序的跳转，下面例子中并不是真的有异常，而是我们利用try...catch的特点实现跳转

void fun
{
    try{
        if (x==0)
            throw new XxxException("Xxx");
        else
            throw new YyyException("Yyy");
    }
    catch(XxxException e)
    {...}
    catch(YyyException e)
    {...}
}

finally关键字

使用这个关键字，在一般情况下不管程序是跳转到了哪种异常或者是没有异常，都会去执行finally中的代码块。那么问题来了，我catch后面的最后一个输出语句，也是不论有没有异常也会执行啊，何必要用一个finally呢？下面我们来看区别

class Test
{
    public int divide(int x,int y) throws ArithmeticException,DivideByMinusException
    {
        if(y<0)
            throw new DivideByMinusException("the divisor is negative "+y);
        //这里抛出的异常对象，就是catch(Exception e)中的e
        int result=x/y;
        return result;
    }
}
class DivideByMinusException extends Exception
{
    public DivideByMinusException(String msg)
    {
        super(msg);
    }
}
class TestException
{
    public static void main(String [] args)
    {
        Test t=new Test();
        try{
            t.divide(2,-1);
            System.out.println("the divide opration is over");
        }
        catch(ArithmeticException e)
        {
            System.out.println("Error ~ ArithmeticException");
            e.printStackTrace();//Exception类中的方法
        }
        
        catch(DivideByMinusException e)
        {
            System.out.println("Error ~ DivideByMinusException");
            e.printStackTrace();
            return;//结束函数，有返回值的返回值，所以不会打印出B
            //System.exit(0);//表示程序到此终止
        }
        catch(Exception e)
        {
            System.out.println(e.getMessage());//打印出the divisor is negative -1
            e.printStackTrace();
        }
        finally
        {
            System.out.println("finally~");//A语句
        }
        System.out.println("the program is running here!");//B语句
    }
}
/*
F:\java_example\lesson61>java TestException
Error ~ DivideByMinusException
DivideByMinusException: the divisor is negative -1
        at Test.divide(Test.java:6)
        at TestException.main(Test.java:25)
finally~
*/

加了return之后，没有执行B，但执行了A,说明不管函数有没有返回，finally部分都是要执行的。只有一种情况下，finally不会被执行，就是加了System.exit(0)，表明程序到此结束。

注意：当类中方法有进行异常处理，那其子类若覆盖该方法要么不进行异常处理，要么子类中异常是父类异常的子集。

引入异常机制，可以加强程序的安全性、强健性。