Java基础之Java异常处理机制

Java异常处理

查看一下Java的API:

java.lang

Class Throwable

• java.lang.Object
• • java.lang.Throwable

• All Implemented Interfaces:

  Serializable

  Direct Known Subclasses:

  Error, Exception

• 从这里不难看出

  

  Exception:是处理编译级别错误； Error:是JVM处理级别错误

异常：是导致程序中断运行的一种指令流，如果不对异常进行正确的处理，则可能导致程序的中断执行，造成不必要的损失，所以在程序的设计中必须考虑各种异常的发生，并正确的做好相应的处理，这样才能保证程序的正常执行。

处理异常的几个关键字：

throw  

throws

try {

//异常出现点

}catch(Exception e){  //细粒度的异常放在前面，粗粒度异常放在后面

 //捕获遗产处理

}catch(Exception){

    

}finally{

 //不管是否有异常，都执行。

}

Demo1

public class ExceptionDemo06{public static void main(String args[]){System.out.println("********** 计算开始 ***********") ;int i = 0 ;// 定义整型变量int j = 0 ;// 定义整型变量try{String str1 = args[0] ;// 接收第一个参数String str2 = args[1] ;// 接收第二个参数i = Integer.parseInt(str1) ;// 将第一个参数由字符串变为整型j = Integer.parseInt(str2) ;// 将第二个参数由字符串变为整型int temp = i / j ;// 此处产生了异常System.out.println("两个数字相除的结果：" + temp) ;System.out.println("----------------------------") ;}catch(ArithmeticException e){// 捕获算术异常// System.out.println("算术异常：" + e) ;e.printStackTrace() ;}catch(NumberFormatException e){// 捕获数字转换异常System.out.println("数字转换异常：" + e);}catch(ArrayIndexOutOfBoundsException e){// 捕获数组越界异常System.out.println("数组越界异常：" + e) ;}catch(Exception e){System.out.println("其他异常：" + e) ;}System.out.println("********** 计算结束 ***********") ;}};

        当所有的异常处理的方式是一样得时候就可以使用以上的形式，直接使用Exception进行捕获，当然，在一个
比较细致的开发中是不建议这样使用的，所有的异常最好分别捕获。

问题：

       既然，捕获Exception是最方便的，那么直接捕获Throwable可以不可以？

      首先，这样的做法是可以的，但是正常的开发人员是不会这样去做的，因为在程序的try中只会抛出Exception的子类部分内容，而Throwable中还有Error。

      所以，最高就是Exception.

throws 与throw

throws : 在定义异常时，他会把异常抛出给调用的一方处理，自己不做处理；

class Math{<span style="white-space:pre"></span>public int div(int i,int j) throws Exception{<span style="white-space:pre"></span>// 定义除法操作，如果有异常，则交给被调用处处理<span style="white-space:pre"></span>int temp = i / j ;<span style="white-space:pre"></span>// 计算，但是此处有可能出现异常<span style="white-space:pre"></span>return temp ;<span style="white-space:pre"></span>}};public class ThrowsDemo01{<span style="white-space:pre"></span>public static void main(String args[]){<span style="white-space:pre"></span>Math m = new Math() ;<span style="white-space:pre"></span>// 实例化Math类对象<span style="white-space:pre"></span>try{<span style="white-space:pre"></span>System.out.println("除法操作：" + m.div(10,2)) ;<span style="white-space:pre"></span>}catch(Exception e){<span style="white-space:pre"></span>e.printStackTrace() ;<span style="white-space:pre"></span>// 打印异常<span style="white-space:pre"></span>}<span style="white-space:pre"></span>}};

如果在主方法中不处理任何的异常了，而是交给最大的头，JAVA中的最大的头JVM处理，所以，如果在主方法中使用throws关键字，则表示一切的异常都交给JVM处理。

throw: 它是可以直接抛出一个异常。抛出的异常可以直接抛出异常的实例化对象即可。

public class ThrowDemo01{public static void main(String args[]){try{throw new Exception("自己抛着玩的。") ;// 抛出异常的实例化对象}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 ThrowDemo02{public static void main(String args[]){Math m = new Math() ;try{System.out.println("除法操作：" + m.div(10,0)) ;}catch(Exception e){System.out.println("异常产生：" + e) ;}}};

Exception:存在他的构造方法,可以抛出他的实例化对象；

Exception 与 RuntimeException

我们来看看这段代码：

public class RuntimeExceptionDemo01{public static void main(String args[]){String str = "123" ;// 定义字符串，全部由数字组成int temp = Integer.parseInt(str) ; // 将字符串变为int类型System.out.println(temp * temp) ;// 计算乘方}};

转型的过程中，发生了异常抛出，当上层代码却没有try{  }cath(){  }  捕获异常？原因是NumberFormatException是RuntimeException的子类。

• java.lang.Object
• • java.lang.Throwable
  • • java.lang.Exception
    • • java.lang.RuntimeException
      • • java.lang.IllegalArgumentException
        • • java.lang.NumberFormatException

public static int parseInt(String s)                    throws NumberFormatException

在JAVA异常处理机制中，用Exception必须使用try .....catch 进行处理。如果抛出的RuntimeException的类型，则不是必须使用trt......catch().., 他一旦发生异常，则由JVM处理；

自定义异常

class MyException extends Exception{// 自定义异常类，继承Exception类public MyException(String msg){super(msg) ;// 调用Exception类中有一个参数的构造方法，传递错误信息}};public class DefaultException{public static void main(String args[]){try{throw new MyException("自定义异常。") ; // 抛出异常}catch(Exception e){System.out.println(e) ;}}}

了解断言的作用

public class Test{public static void main(String args[]){int x[] = {1,2,3} ;// 定义数组，长度为3assert x.length==0 : "数组长度不为0" ;// 此处断言数组的长度为0}};