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

异常的概念 指程序中断执行的一种指令流 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){    
                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,0));    
        }    
} 这个就出现异常了哈，结束语句也就不出来了 我们要将异常交给调用处处理哈~~~ 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关键字 ##############################################################

本文出自 “王乾De技术博客” 博客，谢绝转载！