[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理

更新时间：2022-09-13 17:04:37

异常的概念

指程序中断执行的一种指令流

public class Demo01
{
        public static void main(String args[])
        {
                int i = 0;
                int j = 10;
                System.out.println("程序代码执行之前~~~");
                System.out.println(i/j);
                System.out.println("程序代码执行之后~~~");
        }
}

现在我们反过来哈，j/i

public class Demo01
{
        public static void main(String args[])
        {
                int i = 0;
                int j = 10;
                System.out.println("程序代码执行之前~~~");
                System.out.println(j/i);
                System.out.println("程序代码执行之后~~~");
        }
}

异常一旦发生，则在异常发生处之后的所有代码都不再被执行了。

异常的分类

只要一发生了异常，则肯定会抛出一个异常类的实例化对象。
面试问题：RuntimeException与 Exception的区别：
· RuntimeException表示异常可以由JVM进行处理
· Exception：表示用户可以自行处理
· 实际上两个异常并没有太多的区别，用户都是可以处理的。
· Error：不能由用户自行处理的异常。

捕获异常(1)

public class Demo02
{
        public static void main(String args[])
        {
                int i = 0;
                int j = 10;
                System.out.println("程序代码执行之前~~~");
                try
                {
                        //下面跟上可能发生错误的代码段
                        System.out.println(j/i);
                        System.out.println("-------------------");
                }
                catch (ArithmeticException ae)
                {
                        //进行异常处理
                        System.out.println("运算发生了异常~~~");
                }
                System.out.println("程序代码执行之后~~~");
        }
}

加入异常处理之后，程序可以正常的执行完，也可以正常的捕获错误了，但是在try语句中，在发生异常的地方就进行跳转了，所以异常发生语句之后的代码不会被执行。

如果程序中有多个异常要处理呢？
注意：一个新的操作：将字符串的内容变为数字。

public class Demo03
{
        public static void main(String args[])
        {
                String str = "123";
                //将字符串变为数字
                int i = Integer.parseInt(str);
                System.out.println(i*2);
        }
}

在此代码之中，要求字符串的内容必须是由数字组成的。

如果不全是数字，我们来看下效果

public class Demo03
{
        public static void main(String args[])
        {
                String str = "123a";
                //将字符串变为数字
                int i = Integer.parseInt(str);
                System.out.println(i*2);
        }
}

要求：
要求可以在JAVA运行程序的后面加入运行时参数，参数为两个数相除的内容。

public class Demo04
{
        public static void main(String args[])
        {
                //从运行时处接收参数
                int i = Integer.parseInt(args[0]);
                int j = Integer.parseInt(args[1]);
                System.out.println("程序代码执行之前~~~");
                try
                {
                        //下面跟上可能发生错误的代码段
                        System.out.println(i/j);
                        System.out.println("-------------------");
                }
                catch (ArithmeticException ae)
                {
                        //进行异常处理
                        System.out.println("运算发生了异常~~~");
                }
                System.out.println("程序代码执行之后~~~");
        }
}

在以上的程序之中可能存在那些问题呢？
· 如果没有输入参数的时候，则会有错误：ArrayIndexOutOfBoundsException（数组下标越界）

· 如果输入的参数的内容不是数字，则会有错误：NumberFormatException（数字格式化异常）

· 如果输入的被除数为零，则会有错误：ArithmeticException（算术异常）

则此程序代码只有一个catch肯定是不够的，需要处理多个异常。

public class Demo05
{
        public static void main(String args[])
        {
                //从运行时处接收参数
                int i = 0;
                int j = 0;
                System.out.println("程序代码执行之前~~~");
                try
                {
                        i=Integer.parseInt(args[0]);
                        j=Integer.parseInt(args[1]);
                        //下面跟上可能发生错误的代码段
                        System.out.println(i/j);
                        System.out.println("-------------------");
                }
                catch(ArithmeticException ae)
                {
                        //进行异常处理
                        System.out.println(ae);
                        System.out.println("1.运算发生了异常~~~");
                }
                catch(NumberFormatException ne)
                {
                        System.out.println(ne);
                        System.out.println("2.输入的内容不是数字~~~");
                }
                catch(ArrayIndexOutOfBoundsException ae)
                {
                        System.out.println(ae);
                        System.out.println("3.输入的参数个数不正确~~~");
                }
                System.out.println("程序代码执行之后~~~");
        }
}

以上的程序只要是有异常发生了，则会自动找到对应的catch语句，分别进行处理，但是一个程序可能会存在各种问题，那么有可能全部的catch都写出来吗？

ArithmeticException是Exception的子类哈~

public class Demo06
{
        public static void main(String args[])
        {
                //从运行时处接收参数
                int i = 0;
                int j = 0;
                System.out.println("程序代码执行之前~~~");
                try
                {
                        i=Integer.parseInt(args[0]);
                        j=Integer.parseInt(args[1]);
                        //下面跟上可能发生错误的代码段
                        System.out.println(i/j);
                        System.out.println("-------------------");
                }
                catch(ArithmeticException ae)
                {
                        //进行异常处理
                        System.out.println(ae);
                        System.out.println("1.运算发生了异常~~~");
                }
                catch(NumberFormatException ne)
                {
                        System.out.println(ne);
                        System.out.println("2.输入的内容不是数字~~~");
                }
                catch(ArrayIndexOutOfBoundsException ae)
                {
                        System.out.println(ae);
                        System.out.println("3.输入的参数个数不正确~~~");
                }
                catch(Exception e)
                {
                        System.out.println("异常处理");
                }
                System.out.println("程序代码执行之后~~~");
        }
}

以上代码需要注意：
在异常处理中，对于catch语句要求处理更粗的异常要放在处理更细的异常之后。

我们验证下效果哈~

public class Demo07
{
        public static void main(String args[])
        {
                //从运行时处接收参数
                int i = 0;
                int j = 0;
                System.out.println("程序代码执行之前~~~");
                try
                {
                        i=Integer.parseInt(args[0]);
                        j=Integer.parseInt(args[1]);
                        //下面跟上可能发生错误的代码段
                        System.out.println(i/j);
                        System.out.println("-------------------");
                }
                catch(Exception e)
                {
                        System.out.println("异常处理");
                }
                catch(ArithmeticException ae)
                {
                        //进行异常处理
                        System.out.println(ae);
                        System.out.println("1.运算发生了异常~~~");
                }
                catch(NumberFormatException ne)
                {
                        System.out.println(ne);
                        System.out.println("2.输入的内容不是数字~~~");
                }
                catch(ArrayIndexOutOfBoundsException ae)
                {
                        System.out.println(ae);
                        System.out.println("3.输入的参数个数不正确~~~");
                }
                System.out.println("程序代码执行之后~~~");
        }
}

public class Demo08
{
        public static void main(String args[])
        {
                //从运行时处接收参数
                int i = 0;
                int j = 0;
                System.out.println("程序代码执行之前~~~");
                try
                {
                        i=Integer.parseInt(args[0]);
                        j=Integer.parseInt(args[1]);
                        //下面跟上可能发生错误的代码段
                        System.out.println(i/j);
                        System.out.println("-------------------");
                }
                //只要是程序运行时产生的异常肯定可以使用Exception进行接收
                catch(Exception e)
                {
                        System.out.println("异常处理");
                }
                System.out.println("程序代码执行之后~~~");
        }
}

捕获异常（2）

不管是否发生了异常，都要执行finally代码。

class Math{
        public int div(int i,int j){
                return i/j;
        }
}
public class Demo10{
        public static void main(String args[]){
                System.out.println(new Math().div(1,1));
        }
}

这个代码现在没问题哈~

class Math{
        //表示此方法必须被处理异常，必须在调用处处理
        public int div(int i,int j) throws Exception{
                return i/j;
        }
}
public class Demo10{
        public static void main(String args[]){
                System.out.println(new Math().div(1,1));
        }
}

我们必须要对此代码进行catch捕获

class Math{
        //表示此方法必须被处理异常，必须在调用处处理
        public int div(int i,int j) throws Exception{
                return i/j;
        }
}
public class Demo10{
        public static void main(String args[]){
                try{
                        System.out.println(new Math().div(1,1));
                }catch(Exception e){
                        System.out.println(e);
                }
        }
}

正常执行输出哈

class Math{
        //表示此方法必须被处理异常，必须在调用处处理
        public int div(int i,int j) throws Exception{
                return i/j;
        }
}
public class Demo10{
        public static void main(String args[]){
                try{
                        System.out.println(new Math().div(1,0));
                }catch(Exception e){
                        System.out.println(e);
                }
        }
}

出现异常时成功捕获异常

同样道理，既然可以在方法上声明，则肯定也可以在main方法处声明。

class Math{
        //表示此方法必须被处理异常，必须在调用处处理
        public int div(int i,int j) throws Exception{
                return i/j;
        }
}
public class Demo11{
        //此处的错误交给JVM进行处理了
        public static void main(String args[]) throws Exception{
                System.out.println(new Math().div(1,0));
        }
}

public class Demo12{
        public static void main(String args[]){
                throw new Exception("自己抛出的异常~~~");
        }
}

提示要进行try...catch的处理哈~

public class Demo12{
        public static void main(String args[]){
                try{
                        throw new Exception("自己抛出的异常~~~");
                }catch(Exception e){
                        System.out.println(e);
                }
        }
}

这就是throw关键字的作用哈~~~

实际上在开发中：finally、throw、throws都是一起联合使用的。

要求：
定义一个除法操作，要求进入方法之前必须有开始进行除法操作的提示，操作完之后要求有除法操作完成的提示。

class Math{
        public int div(int i,int j){
                System.out.println("开始除法操作~~~");
                int temp=0;
                temp=i/j;
                System.out.println("开始除法操作~~~");
                return temp;
        }
}
public class Demo13{
        public static void main(String args[]){
                System.out.println(new Math().div(1,1));
        }
}

这个就出现异常了哈，结束语句也就不出来了

我们要将异常交给调用处处理哈~~~

class Math{
        //所有的异常肯定交给调用处处理
        public int div(int i,int j) throws Exception{
                System.out.println("开始除法操作~~~");
                int temp=0;
                temp=i/j;
                System.out.println("结束除法操作~~~");
                return temp;
        }
}
public class Demo13{
        public static void main(String args[]){
                try{
                        System.out.println(new Math().div(1,0));
                }catch(Exception e){
                        System.out.println(e);
                }
        }
}

class Math{
        //所有的异常肯定交给调用处处理
        public int div(int i,int j) throws Exception{
                System.out.println("开始除法操作~~~");
                int temp=0;
                //所有的异常不能自己处理，必须交给被调用处处理
                try{
                        temp=i/j;
                }catch(Exception e){
                        //需要把异常往上抛
                        throw e;
                }finally{
                        System.out.println("结束除法操作~~~");
                }
                return temp;
        }
}
public class Demo13{
        public static void main(String args[]){
                try{
                        System.out.println(new Math().div(1,0));
                }catch(Exception e){
                        System.out.println(e);
                }
        }
}

自定义异常，如果学习SSH框架，很多的异常不是JDK本身提供的，需要自己定义的。任何一个类只要继承了Exception类就表示是一个异常类了。

class MyException extends Exception{
        public MyException(String msg){
                super(msg);
        }
        public String toString(){
                return super.getMessage();
        }
}
public class Demo14{
        public static void main(String args[]){
                try{
                        throw new MyException("自己定义的异常~~~");
                }catch(Exception e){
                        System.out.println(e);
                }
        }
}

总结
异常的捕获：try{}catch：try捕获异常，之后把异常类的实例化对象与catch中的类型相比较，如果合适，则进行异常的处理。
Finlly关键字
面试题：
请说出：final和finally关键字的区别
throw和throws关键字

##############################################################

本文转自redking51CTO博客，原文链接：http://blog.51cto.com/redking/130286，如需转载请自行联系原作者

上一篇 : ：关于ETL工具的思考下一篇 : 关于注入(css/c.js)

[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理

相关阅读

推荐文章