Java的异常处理机制

一、异常的概念

在程序开发过程中，可能存在各种错误，有些错误是可以避免的，而有些错误却是想不到的，在 JAVA中把这些有可能发生的错误称为异常。

二、异常的分类

在JAVA中可以捕获的异常（即Exception类的子类）分为可控式异常和运行时异常两种。

2-1可控式异常

在JAVA占把那些可以预知的错误，例如从文件中读取数据、对数据库进行操作等，在程序编译时就能对程序中可能存在的错误进行处理，并给出具体的错误信息，我们把就些错误称为可控式异常。

方法 说明 IOException 当发生某种I/O异常时，抛(rvln)出此异常 SQLException 提供关于数据库访问错误或其他错误信息的异常 ClassNotFoundException 类没有找到异常 NoSuchFieldException 类不包含指定名称的字段时产生的信号 NoSuchMethodException 无法找到某一特定方法时，抛出该异常

Demo_01；
由于在构造方法中加载com.mingrisoft包中的Text类，Java的虚拟机没有找到Text类，从而引发了ClassNotFoundException异常

public class Example_01{    private int num=10;     //成员变量    public int getNum(){    //成员方法        return num;         //返回成员变量    }    public void setNum(int num){  //成员变量        this.num=num;             //设置成员变量的值    }    public Example_01(){           //类的构造方法        try{            Class.forName("com.mingrisoft.Text");   //装载com.mingrisoft包中的Test类        }catch(ClassNotFoundException e){            e.printStackTrace();        }        System.out.println("测试。");       //在控制台输出“测试”    }    public static void main(String args[]){        Example_01 exam=new Example_01();   //创建类的实例        exam.setNum(888);   //调用setNum()方法设置成员变量num的值        System.out.println(exam.getNum());  //调用getNum()方法输出成员变量的值888    }}

2-2运行时异常

在JAVA中夺些错误是不能被编译器检测到的，例如，在进行除法运算时，除数为零，Java的编译器是检测不到的，因而能够正常编译，但是在运行时就会发生异常，我们把这些异常称为运行时异常。

方法 说明 IndexOutBoundsException 指示某集合或数组的索引值超出范围时抛出该异常 NullPointerException 当应用程序试图在需要对象的地方使用null时，抛出该异常 ArthmeticException 当出现异常运算条件时，抛出此异常 IllegalArgumentException 抛出的异常表明方法传递了一个不合法或不正确的参数 ClassCastException 当试图将对象强制转换为不是实例的子类时，抛出此异常

Demo_02
程序发生了ArrayIndexOutBoundsException异常，该异常是IndexOutOfBoundsException异常的子异常。当程序执行到语句“value=ex.getNum(6);”时发生了异常，因为数组的下标越界。

        public class Example_02{                 //创建并初始化具有6个元素的数组        int[] number={100,80,50,70,20,60};         //根据索引值index为数组元素赋值value的方法        public void setNum(int index,int value)         {            //为数组中索引值index处的元素赋值value            number[index]=value;        }        //根据索引值Index获得数组中对应元素值的方法        public int getNum(int index)        {            return number[index];        }        public static void main(String[] args)        {           //创建类的实例            Example_02 ex=new Example_02();            //调用方法获得数组中索引值0处的元素值，即第一个元素的值100            int value=ex.getNum(0);            //输出第一个索引值100            System.out.println(value);            //索引值6超出了数组下标的范围，因此将发生异常，导致程序异常终止，下面的代码将不会被执行            value=ex.getNum(6);            System.out.println(value);            //获得数组的最后一个元素的值60            value=ex.getNum(5);            //输出最后一个元素值60            System.out.println(value);        }    }

2-3算术异常

算术异常即ArthmeticException,是提指被0除产生的异常。在Java语言中，如果一个整数被0整除 ，那么将抛出ArithmeticException,但是浮点数被0整除，将不引发算术异常，这与数学不同。

    public class ExceptionTest{        public static void main(String args[]){            System.out.println("-1.0/0="+(-1.0/0));   //演示负浮点数除0            System.out.println("+1.0/0="+(+1.0/0));   //演示正浮点数除0            try{            System.out.println("-1/0="+(-1/0));   //演示负正数除0            }catch(Exception e){                //e.getMessage();获得具体异常类名称                System.out.println("抛出异常"+e.getMessage());            }            System.out.println("+1.0/0="+(+1/0));  //演示正整数除0            System.out.println("输出结束。");        }    }

2-4数组下标越界异常

数组下标越界异常即ArrayIndexOutOfBoundsException,当数组元素的下标大于数组的最大值时发生。也就是数组元素的下标大于等于数组的长度时发生。最好使用length或者ArrayList避免这种情况发生。

        public class ArrayExceptionTest{            public static void main(String args[]）{                int[] array=new int[5];    //声明一个长度为5的整型数组                Arrays.fill(arry,8);       //将新声明数组的所有元素赋值为8                for(int i=0;i<6;i++){      //遍历输出所有数组元素                    Systme.out.println("array["+i+"]"+array[i]);                }            }    }

三、获取异常信息

在Java中java.lang.Throwable类是所有异常类的超类，该类提供了获得异常信息的方法。
获取异常信息的方法及说明

方法 说明 String getLocalizedMessage() 获得Throwable的本地化描述 String getMessage() 获得此Throwable的详细消息字符串 void printStackTrace() 将此Throwable及其栈踪迹输出至标准错误流 String toString() 获得此Throwable的简短描述

Example_03
测试输出异常信息的方法

    public class Example_03{        public void printBugInfo(){       //定义成员方法            try{                int x=100;              //定义局部变量x                int y=0;                 //定义局部变量y                 int z=x/y;                                     System.out.println(x+"除以"+y+"的商是："+z);            }catch(Exception ex){                ex.printStackTrace();    //输出异常到标准错误流                //使用getMessage()方法输出异常信息                System.out.println("getMessage方法："+ex.getMessage());                //使用getLocalizedMessage()方法输出异常信息                System.out.println("getLocalizedMessage方法"+ex.getLocalizedMessage());                //使用toString()方法输出异常信息                System.out.println("toString方法："+ex.toString());            }        }        public static void main(String args[]){                Example_03 ex=new Example_03();    //创建类的实例                ex.printBugInfo();        //调用方法        }    }

四、处理异常

在Java语言中当程序发生异常时，可以使用try….catch、try…catch…finally、try…finally来处理

注意：〓〓〓〓使用try-catch-finally处理异常时，→→→→→如果有return语句在catch中，finally中的语句不会受到影响,依次执行的顺序是try-catch-finally-return→→→→→如果有return语句在finallY中的第一句，虽然执行顺序不变，但是return之后的语句不会执行。¤¤¤¤¤¤¤¤有一种finally不执行的情况，就是catch语句中出现system.exit(1),退出虚拟机。

4-1使用try…catch处理异常

对于程序中可能发生异常的语句，可以将其添加到try….catch语句块中，这样当程序发生异常时，就可以对其进行相应的处理。

格式如下

    try{        需要正常执行的语句    }catch(Exception ex){        对异常进行处理的语句    }¤¤¤¤¤¤¤¤¤有时会出现多重catch语句块的情况：★引发多种类型的异常    ■排列catch语句的顺序：先子类异常后父类异常    ■发生异常时按顺序逐个匹配    ■只执行第一个与异常类型匹配的catch语句

4-2使用try…catch…finally处理异常

对于程序中可能发生异常的语句,可以将其添加到try…catch…finally语句块中,这样程序异常时,就可以对其进行相应的处理.
格式如下：

    try{        需要正常执行的语句    }catch(Exception ex){        对异常进行处理的语句    }finally{        一定会被处理的语句    }

例:
在项目中创建IO流,分配内存资源.使用完后,在finally中关闭IO流并释放内存资源.

    import java.io.FileInputStream;    import java.io.IOException;    public class Example{        //声明FileInputStream对象in        private FileInputStream in=null;        //定义方法        public void readInfo(){            try{                //创建FileInputStream对象                in=new FileInputStream("src/com/mingrisoft/Closelo.java");                System.out.println("创建IO流,分配内存资源");            }catch(IOException io){                //输出栈踪迹                io.printStackTrace();                System.out.println("创建IO对象发生异常");            }finally{                if(in!=null){                    try{                        //关闭FileInputStream对象in,释放资源                        in.close();                        System.out.println("关闭IO流,释放内存资源");                        }catch(IOException ioe){                            //输出栈踪迹                            ioe.printStackTrace();                            System.out.println("关闭IO对象异常.");                        }                }            }        }        public static void main(String args[]){            //创建对象            //运行错误            Example ex=new Example();            //调用readInfo()方法            ex.readInfo();         }    }

4-3使用try…finally处理异常

对于程序可能发生异常的语句,可以将其添加到try…finally语句块中,这样当程序发生异常时,就可以在finally语句块中对其进行相应的处理,另版主当程序没有异常时,执行完try和finally之间的语句后,也将执行finally语句块中的代码,因此在finally语句块中旋转一些必须执行的代码,如释放内存的代码等.

格式如下：

    try{        需要执行的句子    }finally{        一定会被处理的语句    }

使用try…finally语句块对程序进行异常处理和资源释放.

    import java.io.IOException;    import java.io.FileInputStream;    public class Example{        //创建FileReader的对象Read        private FileReader read=null;        //定义方法        public void readFileInfo(){            try{                try{                    read=new FileRoader("src/com/mingrisoft/Example.java");                    System.out.println("找到指定文件,创建IO对象成功!");                }catch(FileNotFoundException e){                    //输出栈踪迹                    e.printStackTrace();                }            }finally{                if(read!=null){                    try{                        //关闭FileReader对象read,释放资源                        read.close();                        System.out.println("关闭IO流对象!");                    }catch(IOException ioe){                        //输出栈踪迹                        ioe.printStackTrace();                        System.out.println("关闭IO对象发生异常.");                        }                }            }        }        public static void main(String args[]){            //创建对象            Example ex=new Example();            //调用readFileInfo()方法            ex.readFileInfo();        }    }

五、抛出异常

5.1使用throws声明抛出异常

throws通常用于方法声明，当方法中可能存在异常时，却不想在方法中对异常进行处理时，就可以在声明方法时使用throws声明抛出异常，然后在调用方法的其他方法中对异常进行处理（如使用try...catch语句或使用throws声明抛出异常。格式如下

        数据类型  方法名(型式参数列表） throws 异常类1，异常类2，......，异常类n{            方法体;        }〓〓〓〓〓〓如果子类继承父类，父类有异常产生并把异常抛出，而子类也不做处理并把异常继续抛出，这时一定要注意，子类异常的类型一定要大于或者等于其父类的异常类型。

例：

        import java.io.IOException;        import java.io.FileInputStream;        public class Exception{            /*            //使用throws抛出Exception异常            public void showInfo() throws Exception{                FileInputStream in=new FileInputStream("c:/Record.txt");            }            //定义methodName()方法，该方法调用了上面定义的showInfo()方法，并对showInfo方法抛出的异常进行处理            void methodName(){                try{                    showInfo();                }                }catch(Exception ex){                    System.out.println(ex.getMessage());                }                //声明FileReader对象read                private FileReade read=null;                //定义方法，使用throws抛出Exception异常                public void createFile() throws Exception{                    //创建FileReader对象read                    read=new FileReader("src/com/mingrisoft/Exception.java");                    System.out.println("分配内存资源");                }                */                public void test();                    try{                    //调用createFile()方法，使用try...catch...finally语句处理异常                        createFile();                    }catch(Exception ex){                        //输出栈迹                        ex.printStackTrace();                        System.out.println("创建IO流对象异常"):                    }finally{                        if(read!=null){                            try{                                //关闭IO流                                read.close();                                System.out.println("释放内存资源");                                }catch(IOException e){                                    //输出栈踪迹                                    e.printStackTrace();                                    System.out.println("关闭IO对象异常");                                }                            }                    }        }

5.2使用throw语句抛出异常

在通常情况下，程序发生错误时系统会自动抛出异常，而有时希望程序自行抛出异常，可以使用throw来实现。throw语句通常用在方法中，在程序中自行抛出异常，使用throw语句抛出的是异常类的实例，通常与if一起使用throw语句的语法格式如下：

    throw new Exception("对异常的说明");

例：

    public class Throw{        //圆周率        final static double PI=3.14;        //根据半径计算圆面积的方法        public void computeArea(double r)throws Exception{            if(r<=20.0){                //使用throw语句抛出异常                throw new Exception("程序异常：\n半径为"+r+"\n半径不能小于20.");                }else{                    //计算圆面积                    double circleArea=PI*r*r;                    System.out.println("半径是"+r+"的圆的面积是:"+circleArea);                }            }            public static void main(String args[]){                //创建对象                Throw ex=new Throw();                try{                    //调用方法                    ex.computeArea(10);                }catch(Exception e){                    //输出异常信息                    System.out.println(e.getMessage());                }            }    }

5.4方法上抛出异常

public class ThrowsException{    //抛出异常    public static void throwsException() throws ClassNotFoundException{        Class.forName("com.mysql.jdbc.Driver");    }    public static void main(String args[]){        try{            //捕获异常            ThrowsException.throwsException();            //调用抛出异常的方法        }catch(ClassNotFoundException e){            e.printStackTrace();        }    }}

六、自定义异常

创建自定义的异常类需要继承自Exception类，并提供含有一个String类型，并提供一含有一个String类型的形参的构造方法 ，该形参就是异常的描述信息，可以通过getMessage()方法获得。例如：

6.1创建自定义异常类NewException

    public class NewException extends Exception{    public NewException(String s){        super(s);    }}

6.2使用自定义异常类

自定义异常类的代码

    //创建自定义异常类public class NewException extends Exception{    //有一个Double类型的形参    public NewException(double r){        System.out.println("发生异常：圆的半径不能小于20");        System.out.println("圆的半径为："+r);    }}

newException1的代码

public class newException1{        //创建求圆面积的方法    public static void showArea(double r) throws NewException{        if(r<=20){        //抛出异常            throw new NewException(r);        }        //计算圆面积        double area=3.14*r*r;        //输出圆面积        System.out.println("圆的面积是："+area);    }    public static void main(String args[]){        try{            //调用showArea()方法            showArea(10);        }catch(NewException ex){            //输出异常信息            System.out.println(ex);        }    }}

7.1典例1：捕获单个异常

当遇到异常抛出，还可以将其捕获。抛出异常虽然简单，但是有时却不得不使用捕获来处理异常。如果程序遇到异常而没能捕获，则程序会直接退出。这在大多数情况下是不能接受的，至少保存程序当前状态才能退出。

public class CatchException {    public static void main(String[] args) {        try{            System.out.println("进入try语句块");            @SuppressWarnings("unused")            Class<?>clazz=Class.forName("");            System.out.println("离开try语句块");        }catch(ClassNotFoundException e){            System.out.println("进入语句块");            e.printStackTrace();            System.out.println("离开语句块");            }finally{            System.out.println("进入finally语句块");        }    }}