首页推荐Java学习笔记程序员

Java异常处理机制详解

2017-03-13  本文已影响505人  iDaniel

初识异常（Exception）

发生异常的原因有很多，但是通常有以下几大类：输入了违法的数据、找不到要打开的文件、网络通信中断、JVM内存溢出。

Java异常类层次

Java是通过Throwable类的所有子类来描述各种异常。所有异常的老祖宗都是Throwable。

Throwable.png
Throwable
Throwable 类是所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 中的参数类型。Throwable类有两个重要的子类：Exception（异常）和 Error（错误）。
Error
Java程序通常不捕获错误，出现错误一般都出现了比较严重的故障，此时程序已经无法处理了，然后在控制台通知你，我已经歇菜了。大多数错误与程序的执行操作无关，而是程序运行时，JVM出了问题，如系统崩溃，虚拟机错误，内存空间不足等。这些错误，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。
Exception
Exception类表示程序可以处理的异常，是可以捕获且可能恢复的。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。通常，Java的异常(包括Exception和Error)分为可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。

可查异常、不可查异常

异常方法

下面的列表是 Throwable 类的主要方法:


Method.png

异常处理机制

在 Java 应用程序中，异常处理机制为：抛出异常，捕捉异常。异常总是先被抛出，后被捕捉的。

public class ClassName
{
  public void named(String string) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
}

一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。

public class ClassName
{
   public void withdraw(double amount) throws RemoteException, InsufficientFundsException
   {
       // Method implementation
   }
   //Remainder of class definition
}

try
{
   // 程序代码
}catch(ExceptionName e)
{
   //Catch 块
}

当try内的监控区域发生异常，就会匹配后面的catch块。Java方法在运行过程中出现异常，则创建异常对象。将异常抛出监控区域之外，由Java运行时系统试图寻找匹配的catch子句以捕获异常。若有匹配的catch子句，则运行其异常处理代码，try-catch语句结束。
匹配的原则是：如果抛出的异常对象属于catch块的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型相匹配。
try/catch 实例：

public class Test{

    public static void main(String args[]){
        try{
            int a[] = new int[2];
            System.out.println("输出数组 :" + a[3]);
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("抛出异常  :" + e);
        }
    }
}

多重捕获块：

try{
   // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}

如果监控区域发生异常，异常被抛给第一个 catch 块。如果抛出异常的数据类型与 ExceptionType1 匹配，它在这里就会被捕获。如果不匹配，它会被传递给第二个 catch 块。如此，直到异常被捕获或者通过所有的 catch 块。
多重捕获块实例：

public class TestException {  
    public static void main(String[] args) {  
        int[] intArray = new int[3];  
        try {  
            for (int i = 0; i <= intArray.length; i++) {  
                intArray[i] = i;  
                System.out.println("intArray[" + i + "] = " + intArray[i]);  
                System.out.println("intArray[" + i + "]模 " + (i - 2) + "的值:  "  
                        + intArray[i] % (i - 2));  
            }  
        } catch (ArrayIndexOutOfBoundsException e) {  
            System.out.println("intArray数组下标越界异常。");  
        } catch (ArithmeticException e) {  
            System.out.println("除数为0异常。");  
        }  
        System.out.println("程序正常结束。");  
    }  
} 
//intArray[0] = 0
//intArray[0]模 -2的值:  0
//intArray[1] = 1
//intArray[1]模 -1的值:  0
//intArray[2] = 2
//除数为0异常。
//程序正常结束。

注意：一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。
finally关键字
① 无论是否发生异常，finally 代码块中的代码总会被执行。
② 在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
③ finally 代码块出现在 catch 代码块最后。
④ finally中使用return是一种很不好的编程风格，它会覆盖掉所有的其它返回，并且吃掉catch中抛出的异常。
语法如下：

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}

代码实例：

public class ExcepTest{
  public static void main(String args[]){
    int a[] = new int[2];
    try{
       System.out.println("Access element three :" + a[3]);
    }catch(ArrayIndexOutOfBoundsException e){
       System.out.println("Exception thrown  :" + e);
    }
    finally{
       a[0] = 6;
       System.out.println("First element value: " +a[0]);
       System.out.println("The finally statement is executed");
    }
  }
}
//Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
//First element value: 6
//The finally statement is executed

注意：当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在finally语句块中发生了异常，finally块不会被执行。
try-catch-finally执行顺序
1)当try没有捕获到异常时：try语句块中的语句逐一被执行，程序将跳过catch语句块，执行finally语句块和其后的语句；
2)当try捕获到异常，catch语句块里没有处理此异常的情况：当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时，此异常将会抛给JVM处理，finally语句块里的语句还是会被执行，但finally语句块后的语句不会被执行；
3)当try捕获到异常，catch语句块里有处理此异常的情况：在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理程序，其他的catch语句块将不会被执行，而try语句块中，出现异常之后的语句也不会被执行，catch语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句；

自定义异常

import java.lang.Exception;  
public class TestException {  
    static int quotient(int x, int y) throws MyException { // 定义方法抛出异常  
        if (y < 0) { // 判断参数是否小于0  
            throw new MyException("除数不能是负数"); // 异常信息  
        }  
        return x/y; // 返回值  
    }  
    public static void main(String args[]) { // 主方法  
        int  a =3;  
        int  b =0;   
        try { // try语句包含可能发生异常的语句  
            int result = quotient(a, b); // 调用方法quotient()  
        } catch (MyException e) { // 处理自定义异常  
            System.out.println(e.getMessage()); // 输出异常信息  
        } catch (ArithmeticException e) { // 处理ArithmeticException异常  
            System.out.println("除数不能为0"); // 输出提示信息  
        } catch (Exception e) { // 处理其他异常  
            System.out.println("程序发生了其他的异常"); // 输出提示信息  
        }  
    }  
  
}  
class MyException extends Exception { // 创建自定义异常类  
    String message; // 定义String类型变量  
    public MyException(String ErrorMessagr) { // 父类方法  
        message = ErrorMessagr;  
    }  
  
    public String getMessage() { // 覆盖getMessage()方法  
        return message;  
    }  
}

注意
子类重写父类的方法的时候，如果父类没有异常，那么子类也不允许在重写的方法抛出异常有异常。也就是说父类没有抛出异常，那么子类也不可以。

写完喽！ㄟ(▔,▔)ㄏㄟ(▔,▔)ㄏㄟ(▔,▔)ㄏ

知识重在总结和梳理，只有不断地去学习并运用，才能化为自己的东西。当你能为别人讲明白的时候，说明自己已经掌握了。

欢迎转载，转载请注明出处！

如果有错误的地方，或者有您的见解，还请不啬赐教！

喜欢的话，麻烦点个赞！

本文转载自：http://blog.csdn.net/hguisu/article/details/6155636

l

上一篇 下一篇

猜你喜欢

热点阅读