1、课程名称：异常的捕获及处理
2、知识点
2.1、上次课程的主要知识点
1、    Object类的作用；
2、    链表的操作；
3、    匿名内部类的定义及；
4、    包装类的作用；
5、    JDK 1.5新特性。
2.2、本次预计讲解的知识点
1、    异常的产生及主要问题；
2、    异常处理的流程；
3、    异常类的组成结构以及标准的异常处理格式；
4、    断言的使用；
5、    自定义异常类。
3、具体内容
3.1、认识异常（重点）
    在程序之中异常是导致程序中断执行的一种指令流，一旦产生了异常之后，程序将立刻终止执行，在最早的时候，如果要想避免异常，则需要编写大量的if…else语句进行更加合理的判断，但是Java中引入了异常处理机制之后，对于此类问题就变的相当容易了，但是，先来观察一下异常的产生效果：
public class TestDemo {
    public static void main(String args[]){
        System.out.println("===== 计算开始 =====") ;
        int temp = 10 / 3 ;    // 进行除法计算
        System.out.println("计算结果：" + temp) ;
        System.out.println("===== 计算结束 =====") ;
    }
}
程序输出：
===== 计算开始 =====
计算结果：3
===== 计算结束 =====
    现在的程序之中没有发生任何的意外情况，所以最终的结果是正常的，但是下面修改一下程序。
public class TestDemo {
    public static void main(String args[]){
        System.out.println("===== 计算开始 =====") ;
        int temp = 10 / 0 ;    // 进行除法计算
        System.out.println("计算结果：" + temp) ;
        System.out.println("===== 计算结束 =====") ;
    }
}
输出结果：
===== 计算开始 =====
Exception in thread "main" java.lang.ArithmeticException: / by zero
        at TestDemo.main(TestDemo.java:4)
    程序在计算处出现了异常，所以出现异常之后的代码不再执行了，即：程序被中断了。
3.2、异常处理的格式（重点）
    如果异常出现之后没有进行合理的操作，则程序将会中断执行，则这个时候就可以通过如下的格式进行异常的处理，这样保证在程序出现异常的时候也不会中断程序。
try{
    有可能出现异常的语句
} catch (异常类 异常类对象) {
    异常的处理
} [ catch (异常类 异常类对象) {
    异常的处理
}..] [finally {
    异常处理的出口
}]
范例：在程序中使用异常处理
public class TestDemo {
    public static void main(String args[]){
        System.out.println("===== 计算开始 =====") ;
        try{
            int temp = 10 / 0 ;    // 进行除法计算
            System.out.println("计算结果：" + temp) ;
        }catch(ArithmeticException e){
            System.out.println(e) ;
        }
        System.out.println("===== 计算结束 =====") ;
    }
}
    加入异常处理之后，程序可以正常的执行完毕，
public class TestDemo {
    public static void main(String args[]){
        System.out.println("===== 计算开始 =====") ;
        try{
            int temp = 10 / 2 ;    // 进行除法计算
            System.out.println("计算结果：" + temp) ;
        }catch(ArithmeticException e){
            e.printStackTrace() ;    // 打印异常信息最全
        }
        System.out.println("===== 计算结束 =====") ;
    }
}
    不管在何处，只要异常产生了，则异常产生之后的语句都不再执行，而且一旦有异常之后，肯定要跑到相应的catch语句之中执行，如果现在没有异常，则程序可以正常的执行完毕。
    在异常的处理语句之中，也可以加上finally，这样不管是否出现异常，则最终都会执行此操作。
public class TestDemo {
    public static void main(String args[]){
        System.out.println("===== 计算开始 =====") ;
        try{
            int temp = 10 / 0 ;    // 进行除法计算
            System.out.println("计算结果：" + temp) ;
        }catch(ArithmeticException e){
            e.printStackTrace() ;    // 打印异常信息最全
        }finally{
            System.out.println("都会执行。") ;
        }
        System.out.println("===== 计算结束 =====") ;
    }
}
    而且一个try语句之后可以同时捕获多种类型的异常。
public class TestDemo {
    public static void main(String args[]){
        System.out.println("===== 计算开始 =====") ;
        try{
            int x = Integer.parseInt(args[0]) ;
            int y = Integer.parseInt(args[1]) ;
            int temp = x / y ;    // 进行除法计算
            System.out.println("计算结果：" + temp) ;
try catch的使用方法        }catch(ArithmeticException e){
            e.printStackTrace() ;    // 打印异常信息最全
        }catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace() ;
        }catch(NumberFormatException e){
            e.printStackTrace() ;
        }finally{
            System.out.println("都会执行。") ;
        }
        System.out.println("===== 计算结束 =====") ;
    }
}
    本程序有如下几种异常：
        · 如果程序没有输入参数，则出现：ArrayIndexOutOfBoundsException
        · 如果输入的参数不是数字，则出现：NumberFormatException
    这个程序之中现在的确处理了多个异常，但是问题也非常的明显，你如何知道一个操作会有多少种异常呢？
3.3、异常的组织及处理结构（重点）
    之前已经大概的清楚了异常的产生问题及处理的格式，但是实际上在java的异常之中，包含的范围有两点：程序中的异常、另外一个表示的是系统的错误，而这两点有时候为了省事，才直接将其都统一称为异常，而Java之中的类的继承结构里面也可以发现Throwable类，里面分为两个子类：
        · Exception：表示程序中出现的代码异常，由开发人员进行处理；
        · Error：表示的是JVM的错误，程序开发人员无法处理。
    虽然Throwable表示的范围更加的广泛，但是在实际的工作之中却很少有地方直接使用Throwable进行异常的表示，因为其表示的范围太过于宽广，所以习惯在程序中使用Exception表示所处理的异常。
    但是，要想充分的发挥出以上的继承关系，还需要进一步的了解异常的处理流程。
    对于java程序来讲，如果程序中一旦出现了异常，则会由JVM自动的产生一个Exception子类的对象，之后就好比方法的参数接收那样，catch语句中的异常类型要和抛出的异常对象进行比较，如果比较成功了，则认为当前抛出的这个异常满足与catch语句中的参数的类型，则表示可以使用此catch进行处理，而如果没有匹配的catch呢，则程序会认为此异常无法处理则交给JVM做默认的处理方式（中断执行）。
    而最后不管是否产生了异常都会以finally的代码作为程序的出口。
    既然现在已经掌握了此过程，那么对于异常的接收就可以进一步了，因为按照面向对象的多态性来讲，所有的子类的对象都可以使用父类接收，所以在异常的处理之中，如果为
了省事，可以直接Exception接收所有产生的异常类的实例化对象。
    但是这样一来有一个注意点，就是捕获范围广的异常一定要放在捕获范围小的异常之后。
public class TestDemo {
    public static void main(String args[]){
        System.out.println("===== 计算开始 =====") ;
        try{
            int x = Integer.parseInt(args[0]) ;
            int y = Integer.parseInt(args[1]) ;
            int temp = x / y ;    // 进行除法计算
            System.out.println("计算结果：" + temp) ;
        }catch(Exception e){
            e.printStackTrace() ;
        }finally{
            System.out.println("都会执行。") ;
        }
        System.out.println("===== 计算结束 =====") ;
    }
}
    以上这种简便的做法只适合于异常情况处理要求简单的条件下，如果现在开发要求中需要将每个异常分别处理的话，则就必须采用多个catch语句的形式了。
3.4、throws关键字（重点）
    在异常的处理之中，throws关键字主要是用于方法的声明上的，一旦在方法上使用了throws关键字之后，则表示此方法出现的异常不是由此方法自己处理，而是交给被调用处完成。
class MyMath {
    public int div(int x,int y) throws Exception {
        return x / y ;
    }
}
public class TestDemo {
    public static void main(String args[]){
        try{
            System.out.println(new MyMath().div(10,0)) ;
        }catch(Exception e){
            e.printStackTrace() ;
        }
    }
}
    方法本身不再进行任何的异常处理，而是要将异常交给被调用处完成，但是此时调用处由于不确定方法中最终是否会产生异常，所以必须按照有可能产生异常的方式来进行处理。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。