异常的概念
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_零基础学JAVA
指程序中断执行的一种指令流
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("程序代码执行之后~~~");    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_throw_02
现在我们反过来哈,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("程序代码执行之后~~~");    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_throw_03
异常一旦发生,则在异常发生处之后的所有代码都不再被执行了。
异常的分类
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_JAVA_04
只要一发生了异常,则肯定会抛出一个异常类的实例化对象。
面试问题:RuntimeException与 Exception的区别:
  ·  RuntimeException表示异常可以由JVM进行处理
  ·  Exception:表示用户可以自行处理
  · 实际上两个异常并没有太多的区别,用户都是可以处理的。
  ·  Error:不能由用户自行处理的异常。
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_零基础学JAVA_05
捕获异常(1)
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_面向对象_06
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("程序代码执行之后~~~");    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_面向对象_07
加入异常处理之后,程序可以正常的执行完,也可以正常的捕获错误了,但是在try语句中,在发生异常的地方就进行跳转了,所以异常发生语句之后的代码不会被执行。
如果程序中有多个异常要处理呢?
注意:一个新的操作:将字符串的内容变为数字。
public class Demo03    
{    
        public static void main(String args[])    
        {    
                String str = "123";    
                //将字符串变为数字    
                int i = Integer.parseInt(str);    
                System.out.println(i*2);    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_面向对象_08
在此代码之中,要求字符串的内容必须是由数字组成的。
如果不全是数字,我们来看下效果
public class Demo03    
{    
        public static void main(String args[])    
        {    
                String str = "123a";    
                //将字符串变为数字    
                int i = Integer.parseInt(str);    
                System.out.println(i*2);    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_零基础学JAVA_09
要求:
  要求可以在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("程序代码执行之后~~~");    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_面向对象_10
在以上的程序之中可能存在那些问题呢?
  · 如果没有输入参数的时候,则会有错误:ArrayIndexOutOfBoundsException(数组下标越界)
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_零基础学JAVA_11
  · 如果输入的参数的内容不是数字,则会有错误:NumberFormatException(数字格式化异常)
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_throw_12
  · 如果输入的被除数为零,则会有错误:ArithmeticException(算术异常)
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_异常处理_13
则此程序代码只有一个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("程序代码执行之后~~~");    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_throw_14
以上的程序只要是有异常发生了,则会自动找到对应的catch语句,分别进行处理,但是一个程序可能会存在各种问题,那么有可能全部的catch都写出来吗?
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_零基础学JAVA_15 ArithmeticException是Exception的子类哈~[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_异常处理_16
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("程序代码执行之后~~~");    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_异常处理_17
以上代码需要注意:
  在异常处理中,对于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("程序代码执行之后~~~");    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_throw_18
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("程序代码执行之后~~~");    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_throw_19
捕获异常(2)
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_JAVA_20 
不管是否发生了异常,都要执行finally代码。
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_异常处理_21
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_零基础学JAVA_22
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));        
        }    
}
这个代码现在没问题哈~
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_throw_23 
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));        
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_JAVA_24
我们必须要对此代码进行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);    
                }    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_异常处理_25
正常执行输出哈
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);    
                }    
        }    
}
出现异常时成功捕获异常
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_异常处理_26
同样道理,既然可以在方法上声明,则肯定也可以在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));    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_零基础学JAVA_27
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_零基础学JAVA_28
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_JAVA_29
public class Demo12{    
        public static void main(String args[]){    
                throw new Exception("自己抛出的异常~~~");    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_throw_30
提示要进行try...catch的处理哈~
public class Demo12{    
        public static void main(String args[]){    
                try{    
                        throw new Exception("自己抛出的异常~~~");    
                }catch(Exception e){    
                        System.out.println(e);    
                }    
        }    
}
这就是throw关键字的作用哈~~~
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_异常处理_31
实际上在开发中: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));    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_throw_32
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));    
        }    
}
这个就出现异常了哈,结束语句也就不出来了
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_零基础学JAVA_33
我们要将异常交给调用处处理哈~~~
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);    
                }    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_throw_34
 
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);    
                }    
        }    
}

[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_throw_35
自定义异常,如果学习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);    
                }    
        }    
}
[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理_面向对象_36
总结
异常的捕获:try{}catch:try捕获异常,之后把异常类的实例化对象与catch中的类型相比较,如果合适,则进行异常的处理。
Finlly关键字
面试题:
请说出:final和finally关键字的区别
throw和throws关键字
##############################################################