精华内容
下载资源
问答
  • java(3)-深入理解java异常处理机制

    万次阅读 多人点赞 2011-01-20 18:44:00
    例1 在try监控区域通过if语句进行判断,当“除数为0”的错误条件成立时引发ArithmeticException异常,创建 ArithmeticException异常对象,由throw语句将异常抛给Java运行时系统,由系统寻找匹配的异常处理器...

     

    二.前言:引子


           try…catch…finally恐怕是大家再熟悉不过的语句了,而且感觉用起来也是很简单,逻辑上似乎也是很容易理解。不过,我亲自体验的“教训”告诉我,这个东西可不是想象中的那么简单、听话。不信?那你看看下面的代码,“猜猜”它执行后的结果会是什么?不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确,那么这篇文章你就不用浪费时间看啦。

    package Test;
    
    public class TestException {
    	public TestException() {
    	}
    
    	boolean testEx() throws Exception {
    		boolean ret = true;
    		try {
    			ret = testEx1();
    		} catch (Exception e) {
    			System.out.println("testEx, catch exception");
    			ret = false;
    			throw e;
    		} finally {
    			System.out.println("testEx, finally; return value=" + ret);
    			return ret;
    		}
    	}
    
    	boolean testEx1() throws Exception {
    		boolean ret = true;
    		try {
    			ret = testEx2();
    			if (!ret) {
    				return false;
    			}
    			System.out.println("testEx1, at the end of try");
    			return ret;
    		} catch (Exception e) {
    			System.out.println("testEx1, catch exception");
    			ret = false;
    			throw e;
    		} finally {
    			System.out.println("testEx1, finally; return value=" + ret);
    			return ret;
    		}
    	}
    
    	boolean testEx2() throws Exception {
    		boolean ret = true;
    		try {
    			int b = 12;
    			int c;
    			for (int i = 2; i >= -2; i--) {
    				c = b / i;
    				System.out.println("i=" + i);
    			}
    			return true;
    		} catch (Exception e) {
    			System.out.println("testEx2, catch exception");
    			ret = false;
    			throw e;
    		} finally {
    			System.out.println("testEx2, finally; return value=" + ret);
    			return ret;
    		}
    	}
    
    	public static void main(String[] args) {
    		TestException testException1 = new TestException();
    		try {
    			testException1.testEx();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    

    你的答案是什么?是下面的答案吗?

    i=2
    i=1
    testEx2, catch exception
    testEx2, finally; return value=false
    testEx1, catch exception
    testEx1, finally; return value=false
    testEx, catch exception
    testEx, finally; return value=false

    如果你的答案真的如上面所说,那么你错啦。^_^,那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改、执行、测试,你会发现有很多事情不是原来想象中的那么简单的。现在公布正确答案:

    i=2
    i=1
    testEx2, catch exception
    testEx2, finally; return value=false
    testEx1, finally; return value=false
    testEx, finally; return value=false

     

    注意说明:

    finally语句块不应该出现 应该出现return。上面的return ret最好是其他语句来处理相关逻辑。

     

    二.JAVA异常


       异常指不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。异常是一个事件,它发生在程序运行期间,干扰了正常的指令流程。Java通 过API中Throwable类的众多子类描述各种不同的异常。因而,Java异常都是对象,是Throwable子类的实例,描述了出现在一段编码中的 错误条件。当条件生成时,错误将引发异常。

          Java异常类层次结构图:

     

            

     

     

                                                                        图1 Java异常类层次结构图

     

     

            在 Java 中,所有的异常都有一个共同的祖先 Throwable(可抛出)。Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。
           Throwable: 有两个重要的子类:Exception(异常)和 Error(错误),二者都是 Java 异常处理的重要子类,各自都包含大量子类。

     

           Error(错误):是程序无法处理的错误,表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关,而表示代码运行时 JVM(Java 虚拟机)出现的问题。例如,Java虚拟机运行错误(Virtual MachineError),当 JVM 不再有继续执行操作所需的内存资源时,将出现 OutOfMemoryError。这些异常发生时,Java虚拟机(JVM)一般会选择线程终止。

    。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时,如Java虚拟机运行错误(Virtual MachineError)、类定义错误(NoClassDefFoundError)等。这些错误是不可查的,因为它们在应用程序的控制和处理能力之 外,而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说,即使确实发生了错误,本质上也不应该试图去处理它所引起的异常状况。在 Java中,错误通过Error的子类描述。

           Exception(异常):是程序本身可以处理的异常。

           Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如,若试图使用空值对象引用、除数为零或数组越界,则分别引发运行时异常(NullPointerException、ArithmeticException)和 ArrayIndexOutOfBoundException。

       注意:异常和错误的区别:异常能被程序本身可以处理,错误是无法处理。

       通常,Java的异常(包括Exception和Error)分为可查的异常(checked exceptions)和不可查的异常(unchecked exceptions)
          可查异常(编译器要求必须处置的异常):正确的程序在运行中,很容易出现的、情理可容的异常状况。可查异常虽然是异常状况,但在一定程度上它的发生是可以预计的,而且一旦发生这种异常状况,就必须采取某种方式进行处理。

          除了RuntimeException及其子类以外,其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它,也就是说,当程序中可能出现这类异常,要么用try-catch语句捕获它,要么用throws子句声明抛出它,否则编译不会通过。

         不可查异常(编译器不要求强制处置的异常):包括运行时异常(RuntimeException与其子类)和错误(Error)。

         Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。

           运行时异常:都是RuntimeException类及其子类异常,如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等,这些异常是不检查异常,程序中可以选择捕获处理,也可以不处理。这些异常一般是由程序逻辑错误引起的,程序应该从逻辑角度尽可能避免这类异常的发生。

          运行时异常的特点是Java编译器不会检查它,也就是说,当程序中可能出现这类异常,即使没有用try-catch语句捕获它,也没有用throws子句声明抛出它,也会编译通过。
           非运行时异常 (编译异常):是RuntimeException以外的异常,类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常,如果不处理,程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常,一般情况下不自定义检查异常

      

    三.处理异常机制


            在 Java 应用程序中,异常处理机制为:抛出异常,捕捉异常。

            抛出异常当一个方法出现错误引发异常时,方法创建异常对象并交付运行时系统,异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。

            捕获异常:在方法抛出异常之后,运行时系统将转为寻找合适的异常处理器(exception handler)。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时,即为合适 的异常处理器。运行时系统从发生异常的方法开始,依次回查调用栈中的方法,直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器,则运行时系统终止。同时,意味着Java程序的终止。

            对于运行时异常、错误或可查异常,Java技术所要求的异常处理方式有所不同。

            由于运行时异常的不可查性,为了更合理、更容易地实现应用程序,Java规定,运行时异常将由Java运行时系统自动抛出,允许应用程序忽略运行时异常。

           对于方法运行中可能出现的Error,当运行方法不欲捕捉时,Java允许该方法不做任何抛出声明。因为,大多数Error异常属于永远不能被允许发生的状况,也属于合理的应用程序不该捕捉的异常。

           对于所有的可查异常,Java规定:一个方法必须捕捉,或者声明抛出方法之外。也就是说,当一个方法选择不捕捉可查异常时,它必须声明将抛出异常。

            能够捕捉异常的方法,需要提供相符类型的异常处理器。所捕捉的异常,可能是由于自身语句所引发并抛出的异常,也可能是由某个调用的方法或者Java运行时 系统等抛出的异常。也就是说,一个方法所能捕捉的异常,一定是Java代码在某处所抛出的异常简单地说,异常总是先被抛出,后被捕捉的。

             任何Java代码都可以抛出异常,如:自己编写的代码、来自Java开发环境包中代码,或者Java运行时系统。无论是谁,都可以通过Java的throw语句抛出异常。

            从方法中抛出的任何异常都必须使用throws子句。

            捕捉异常通过try-catch语句或者try-catch-finally语句实现。

             总体来说,Java规定:对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。

    3.1 捕获异常:try、catch 和 finally

    1.try-catch语句

         在Java中,异常通过try-catch语句捕获。其一般语法形式为:

    try {
        // 可能会发生异常的程序代码
    } catch (Type1 id1){
        // 捕获并处置try抛出的异常类型Type1
    }
    catch (Type2 id2){
         //捕获并处置try抛出的异常类型Type2
    }

     

           关键词try后的一对大括号将一块可能发生异常的代码包起来,称为监控区域。Java方法在运行过程中出现异常,则创建异常对象。将异常抛出监控区域之 外,由Java运行时系统试图寻找匹配的catch子句以捕获异常。若有匹配的catch子句,则运行其异常处理代码,try-catch语句结束。

           匹配的原则是:如果抛出的异常对象属于catch子句的异常类,或者属于该异常类的子类,则认为生成的异常对象与catch块捕获的异常类型相匹配。

    例1  捕捉throw语句抛出的“除数为0”异常。

    public class TestException {
    	public static void main(String[] args) {
    		int a = 6;
    		int b = 0;
    		try { // try监控区域
    			
    			if (b == 0) throw new ArithmeticException(); // 通过throw语句抛出异常
    			System.out.println("a/b的值是:" + a / b);
    		}
    		catch (ArithmeticException e) { // catch捕捉异常
    			System.out.println("程序出现异常,变量b不能为0。");
    		}
    		System.out.println("程序正常结束。");
    	}
    }

    运行结果:程序出现异常,变量b不能为0。

                        程序正常结束。

            例1  在try监控区域通过if语句进行判断,当“除数为0”的错误条件成立时引发ArithmeticException异常,创建 ArithmeticException异常对象,并由throw语句将异常抛给Java运行时系统,由系统寻找匹配的异常处理器catch并运行相应异 常处理代码,打印输出“程序出现异常,变量b不能为0。”try-catch语句结束,继续程序流程。

            事实上,“除数为0”等ArithmeticException,是RuntimException的子类。而运行时异常将由运行时系统自动抛出,不需要使用throw语句。

    例2  捕捉运行时系统自动抛出“除数为0”引发的ArithmeticException异常。

    	public static void main(String[] args) {
    		int a = 6;
    		int b = 0;
    		try {
    			System.out.println("a/b的值是:" + a / b);
    		} catch (ArithmeticException e) {
    			System.out.println("程序出现异常,变量b不能为0。");
    		}
    		System.out.println("程序正常结束。");
    	}
    }

    运行结果:程序出现异常,变量b不能为0。

                      程序正常结束。

    例2  中的语句:

    System.out.println("a/b的值是:" + a/b);

          在运行中出现“除数为0”错误,引发ArithmeticException异常。运行时系统创建异常对象并抛出监控区域,转而匹配合适的异常处理器catch,并执行相应的异常处理代码。

          由于检查运行时异常的代价远大于捕捉异常所带来的益处,运行时异常不可查。Java编译器允许忽略运行时异常,一个方法可以既不捕捉,也不声明抛出运行时异常。

    例3  不捕捉、也不声明抛出运行时异常。

    public class TestException {
    	public static void main(String[] args) {
    		int a, b;
    		a = 6;
    		b = 0; // 除数b 的值为0
    		System.out.println(a / b);
    	}
    }

    运行结果:

    Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Test.TestException.main(TestException.java:8)

    例4  程序可能存在除数为0异常和数组下标越界异常。

    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异常。

    程序正常结束。

          例4  程序可能会出现除数为0异常,还可能会出现数组下标越界异常。程序运行过程中ArithmeticException异常类型是先行匹配的,因此执行相匹配的catch语句:

    catch (ArithmeticException e){
          System.out.println("除数为0异常。");
     }

     

           需要注意的是,一旦某个catch捕获到匹配的异常类型,将进入异常处理代码。一经处理结束,就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。

          Java通过异常类描述异常类型,异常类的层次结构如图1所示。对于有多个catch子句的异常程序而言,应该尽量将捕获底层异常类的catch子 句放在前面,同时尽量将捕获相对高层的异常类的catch子句放在后面。否则,捕获底层异常类的catch子句将可能会被屏蔽。

          RuntimeException异常类包括运行时各种常见的异常,ArithmeticException类和ArrayIndexOutOfBoundsException类都是它的子类。因此,RuntimeException异常类的catch子句应该放在 最后面,否则可能会屏蔽其后的特定异常处理或引起编译错误。

    2. try-catch-finally语句

          try-catch语句还可以包括第三部分,就是finally子句。它表示无论是否出现异常,都应当执行的内容。try-catch-finally语句的一般语法形式为:

                    try {
    			// 可能会发生异常的程序代码
    		} catch (Type1 id1) {
    			// 捕获并处理try抛出的异常类型Type1
    		} catch (Type2 id2) {
    			// 捕获并处理try抛出的异常类型Type2
    		} finally {
    			// 无论是否发生异常,都将执行的语句块
    		}

    例5  带finally子句的异常处理程序。

    public class TestException {
    	public static void main(String args[]) {
    		int i = 0;
    		String greetings[] = { " Hello world !", " Hello World !! ",
    				" HELLO WORLD !!!" };
    		while (i < 4) {
    			try {
    				// 特别注意循环控制变量i的设计,避免造成无限循环
    				System.out.println(greetings[i++]);
    			} catch (ArrayIndexOutOfBoundsException e) {
    				System.out.println("数组下标越界异常");
    			} finally {
    				System.out.println("--------------------------");
    			}
    		}
    	}
    }

    运行结果:

    Hello world !

    --------------------------

    Hello World !!

    --------------------------

    HELLO WORLD !!!

    --------------------------

    数组下标越界异常

    --------------------------

         在例5中,请特别注意try子句中语句块的设计,如果设计为如下,将会出现死循环。如果设计为:

     

    try {
          System.out.println (greetings[i]); i++;
    }

     

    小结:

    try 块:用于捕获异常。其后可接零个或多个catch块,如果没有catch块,则必须跟一个finally块。
    catch 块:用于处理try捕获到的异常。
    finally 块:无论是否捕获或处理异常,finally块里的语句都会被执行。
    当在try块或catch块中遇到return语句时,finally语句块将在方法返回之前被执行。在以下4种特殊情况下,finally块不会被执行:
    1)在finally语句块中发生了异常。
    2)在前面的代码中用了System.exit()退出程序。
    3)程序所在的线程死亡。
    4)关闭CPU。

     

     

    3. try-catch-finally 规则(异常处理语句的语法规则):

    1)  必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块,但至少有一个块。
    2) 必须遵循块顺序:若代码同时使用 catch 和 finally 块,则必须将 catch 块放在 try 块之后。
    3) catch 块与相应的异常类的类型相关。
    4) 一个 try 块可能有多个 catch 块。若如此,则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配,如果异常对象为某个异常类型或其子类的实例,就执行这个catch代码块,不会再执行其他的 catch代码块
    5) 可嵌套 try-catch-finally 结构。
    6) 在 try-catch-finally 结构中,可重新抛出异常。
    7) 除了下列情况,总将执行 finally 做为结束:JVM 过早终止(调用 System.exit(int));在 finally 块中抛出一个未处理的异常;计算机断电、失火、或遭遇病毒攻击。

    4. 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语句块后的语句;

     图示try、catch、finally语句块的执行:

                                              图2  图示try、catch、finally语句块的执行
     

    3.2 抛出异常

          任何Java代码都可以抛出异常,如:自己编写的代码、来自Java开发环境包中代码,或者Java运行时系统。无论是谁,都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。

    1. throws抛出异常

       如果一个方法可能会出现异常,但没有能力处理这种异常,可以在方法声明处用throws子句来声明抛出异常。例如汽车在运行时可能会出现故障,汽车本身没办法处理这个故障,那就让开车的人来处理。

         throws语句用在方法定义时声明该方法要抛出的异常类型,如果抛出的是Exception异常类型,则该方法被声明为抛出所有的异常。多个异常可使用逗号分割。throws语句的语法格式为:

    methodname throws Exception1,Exception2,..,ExceptionN
    {
    }

        方法名后的throws Exception1,Exception2,...,ExceptionN 为声明要抛出的异常列表。当方法抛出异常列表的异常时,方法将不对这些类型及其子类类型的异常作处理,而抛向调用该方法的方法,由他去处理。例如:

     

    import java.lang.Exception;
    public class TestException {
    	static void pop() throws NegativeArraySizeException {
    		// 定义方法并抛出NegativeArraySizeException异常
    		int[] arr = new int[-3]; // 创建数组
    	}
    
    	public static void main(String[] args) { // 主方法
    		try { // try语句处理异常信息
    			pop(); // 调用pop()方法
    		} catch (NegativeArraySizeException e) {
    			System.out.println("pop()方法抛出的异常");// 输出异常信息
    		}
    	}
    
    }

     

        使用throws关键字将异常抛给调用者后,如果调用者不想处理该异常,可以继续向上抛出,但最终要有能够处理该异常的调用者。

        pop方法没有处理异常NegativeArraySizeException,而是由main函数来处理。

        Throws抛出异常的规则:

        1) 如果是不可查异常(unchecked exception),即Error、RuntimeException或它们的子类,那么可以不使用throws关键字来声明要抛出的异常,编译仍能顺利通过,但在运行时会被系统抛出。

        2)必须声明方法可抛出的任何可查异常(checked exception)。即如果一个方法可能出现受可查异常,要么用try-catch语句捕获,要么用throws子句声明将它抛出,否则会导致编译错误

        3)仅当抛出了异常,该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候,应该继续抛出,而不是囫囵吞枣。

     

        4)调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法,则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

        例如:

     

    void method1() throws IOException{}  //合法  
     
    //编译错误,必须捕获或声明抛出IOException  
    void method2(){  
      method1();  
    }  
     
    //合法,声明抛出IOException  
    void method3()throws IOException {  
      method1();  
    }  
     
    //合法,声明抛出Exception,IOException是Exception的子类  
    void method4()throws Exception {  
      method1();  
    }  
     
    //合法,捕获IOException  
    void method5(){  
     try{  
        method1();  
     }catch(IOException e){…}  
    }  
     
    //编译错误,必须捕获或声明抛出Exception  
    void method6(){  
      try{  
        method1();  
      }catch(IOException e){throw new Exception();}  
    }  
     
    //合法,声明抛出Exception  
    void method7()throws Exception{  
     try{  
      method1();  
     }catch(IOException e){throw new Exception();}  
    } 

         判断一个方法可能会出现异常的依据如下:
         1)方法中有throw语句。例如,以上method7()方法的catch代码块有throw语句。
         2)调用了其他方法,其他方法用throws子句声明抛出某种异常。例如,method3()方法调用了method1()方法,method1()方法声明抛出IOException,因此,在method3()方法中可能会出现IOException。

     

    2. 使用throw抛出异常

       throw总是出现在函数体中,用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。
      我们知道,异常是异常类的实例对象,我们可以创建异常类的实例对象通过throw语句抛出。该语句的语法格式为:
        throw new exceptionname;
        例如抛出一个IOException类的异常对象:
        throw new IOException;
        要注意的是,throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象。下面的操作是错误的:
        throw new String("exception");

        这是因为String 不是Throwable 类的子类。

        如果抛出了检查异常,则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。

        如果所有方法都层层上抛获取的异常,最终JVM会进行处理,处理也很简单,就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException,则该方法的调用者可选择处理该异常。

    package Test;
    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;
    	}
    }

    注意:

    1、Throw (是 catch 中还是非 catch 中)后面不能再跟其他代码块了 ,否则编译不能通过,

    例如把return和throw放在一起,IDEA直接提示错误:"Unreachable statement" .

    2、但可以在finally语句块有return语句,finally语句块成功骗过编译器让throw和return两者并存

    我们根据开头引子的例子,可以得出结论:

    finally如果有return会覆盖catch里的throw,同样如果finally里有throw会覆盖catch里的return。

    进而如果catch里和finally都有return, finally中的return会覆盖catch中的。throw也是如此。

     

    3.3 异常链

          1) 如果调用quotient(3,-1),将发生MyException异常,程序调转到catch (MyException e)代码块中执行;

          2) 如果调用quotient(5,0)将会因“除数为0”错误引发ArithmeticException异常,属于运行时异常类,由Java运行时系统自动抛出。quotient()方法没有捕捉ArithmeticException异常,Java运行时系统将沿方法调用栈查到main方法,将抛出的异常上传至quotient()方法的调用者:

             int result = quotient(a, b); // 调用方法quotient()
            由于该语句在try监控区域内,因此传回的“除数为0”的ArithmeticException异常由Java运行时系统抛出,并匹配catch子句:

           catch (ArithmeticException e) { // 处理ArithmeticException异常
    System.out.println("除数不能为0"); // 输出提示信息

            处理结果是输出“除数不能为0”。Java这种向上传递异常信息的处理机制,形成异常链

           Java方法抛出的可查异常将依据调用栈、沿着方法调用的层次结构一直传递到具备处理能力的调用方法,最高层次到main方法为止。如果异常传递到main方法,而main不具备处理能力,也没有通过throws声明抛出该异常,将可能出现编译错误。

     

          3)如还有其他异常发生,将使用catch (Exception e)捕捉异常。由于Exception是所有异常类的父类,如果将catch (Exception e)代码块放在其他两个代码块的前面,后面的代码块将永远得不到执行,就没有什么意义了,所以catch语句的顺序不可掉换。

    3.4 Throwable类中的常用方法

    注意:catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型,e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:

         getCause():返回抛出异常的原因。如果 cause 不存在或未知,则返回 null。

      getMeage():返回异常的消息信息。

      printStackTrace():对象的堆栈跟踪输出至错误输出流,作为字段 System.err 的值。

         有时为了简单会忽略掉catch语句后的代码,这样try-catch语句就成了一种摆设,一旦程序在运行过程中出现了异常,就会忽略处理异常,而错误发生的原因很难查找。

     

    四.try catch finally 语句中有return情况


    1、try中有return语句和最后有return:

    我们看看这段代码的输出结果:

    public class testExcReurn {
        public int add(int a,int b) {
            try {
                return a+b;
            }catch(Exception e){
                System.out.println("catch语句块");
            }finally {
                System.out.println("finally语句块");
            }
            return 0;
        }
        public static void main(String[] args) {
            testExcReurn t = new testExcReurn();
            System.out.println("和="+t.add(9, 34));
        }
    }

    A、catch语句块 和=43
    B、编译异常
    C、finally语句块 和=43
    D、和=43 finally语句块

    正确答案:C

    合理的解释是,在try中执行到return语句时,不会真正的return,即只是会计算return中的表达式,之后将结果保存在一个临时栈中,接着执行finally中的语句,最后才会从临时栈中取出之前的结果返回。

    2、try和finally都有return语句:

    public class testExcReurn {
        public int add(int a,int b) {
            try {
                return a+b;
            }catch(Exception e){
                System.out.println("catch语句块");
            }finally {
                System.out.println("finally语句块");
                return 0;
            }
        }
        public static void main(String[] args) {
            testExcReurn t = new testExcReurn();
            System.out.println("和="+t.add(9, 34));
        }
    }

    finnaly会覆盖try的return语句。

    3、return的数据是引用数据类型

    public class testExcReurn {
        public int a;
        public testExcReurn set() {
            try {
                this.a  = 10;
                return this;
            }catch(Exception e){
                System.out.println("catch语句块");
            }finally {
                System.out.println("finally语句块");
                this.a = 200;
            }
            return this;
        }
        public static void main(String[] args) {
            testExcReurn t = new testExcReurn();
            t.set();
            System.out.println("a="+ t.a);
        }
    }

     

    结论:

    1、finally覆盖catch(开头引子的例子):

          1)如果finally有return会覆盖catch里的throw,同样如果finally里有throw会覆盖catch里的return。

          2) 如果catch里和finally都有return, finally中的return会覆盖catch中的。throw也是如此。

    2、catch有return而finally没有:

         当 try 中抛出异常且catch 中有 return 语句,finally 中没有 return 语句, java 先执行 catch 中非 return 语句,再执行 finally 语句,最后执行 catch 中 return 语句。

    3、try有return语句,后续还有return语句,分为以下三种情况:

        情况一:如果finally中有return语句,则会将try中的return语句”覆盖“掉,直接执行finally中的return语句,得到返回值,这样便无法得到try之前保留好的返回值。

        情况二:如果finally中没有return语句,也没有改变要返回值,则执行完finally中的语句后,会接着执行try中的return语句,返回之前保留的值。

        情况三:如果finally中没有return语句,但是改变了要返回的值,这里有点类似与引用传递和值传递的区别,分以下两种情况,:

            1)如果return的数据是基本数据类型或文本字符串,则在finally中对该基本数据的改变不起作用,try中的return语句依然会返回进入finally块之前保留的值。

            2)如果return的数据是引用数据类型,而在finally中对该引用数据类型的属性值的改变起作用,try中的return语句返回的就是在finally中改变后的该属性的值。

     

     

    五.Java常见异常


    在Java中提供了一些异常用来描述经常发生的错误,对于这些异常,有的需要程序员进行捕获处理或声明抛出,有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:

     

    1. runtimeException子类:

        1、 java.lang.ArrayIndexOutOfBoundsException
        数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
        2、java.lang.ArithmeticException
        算术条件异常。譬如:整数除零等。
        3、java.lang.NullPointerException
        空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
        4、java.lang.ClassNotFoundException
        找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。

       5、java.lang.NegativeArraySizeException  数组长度为负异常

       6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常

       7、java.lang.SecurityException 安全性异常

       8、java.lang.IllegalArgumentException 非法参数异常

    2.IOException

    IOException:操作输入流和输出流时可能出现的异常。

    EOFException   文件已结束异常

    FileNotFoundException   文件未找到异常

    3. 其他

    ClassCastException    类型转换异常类

    ArrayStoreException  数组中包含不兼容的值抛出的异常

    SQLException   操作数据库异常类

    NoSuchFieldException   字段未找到异常

    NoSuchMethodException   方法未找到抛出的异常

    NumberFormatException    字符串转换为数字抛出的异常

    StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常

    IllegalAccessException  不允许访问某类异常

    InstantiationException  当应用程序试图使用Class类中的newInstance()方法创建一个类的实例,而指定的类对象无法被实例化时,抛出该异常

     

     5.自定义异常


    使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外,用户还可以自定义异常。用户自定义异常类,只需继承Exception类即可。
    在程序中使用自定义异常类,大体可分为以下几个步骤:

    1)创建自定义异常类:一般会选择继承Exception和RuntimeException,如果不要求调用者一定要处理抛出的异常,就继承RuntimeException。
    2)抛出自定义异常:在方法中通过throw关键字抛出异常对象。
    3)捕获自定义异常:如果在当前抛出异常的方法中处理异常,可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常,继续进行下一步操作。
    4)在出现异常方法的调用者中捕获并处理异常
    在上面的“使用throw抛出异常”例子已经提到了:

    class MyException extends Exception { // 创建自定义异常类
        String message; // 定义String类型变量
        public MyException(String ErrorMessagr) { // 父类方法
            message = ErrorMessagr;
        }
    
        public String getMessage() { // 覆盖getMessage()方法
            return message;
        }
    }

     

     
    展开全文
  • Java异常

    千次阅读 2014-06-01 05:07:39
    异常处理机制是Java许多特性的zhn

    异常处理机制是Java许多特性的重要基础。Java采用面向对象的方式来处理异常。本文介绍与异常相关的内容。

    1. 什么是异常?

    异常是异常事件(exceptional event)的简写,是程序运行过程中出现的打断(disrupt)正常运行的事件,比如被除数为0导致的程序异常。当程序的方法出现异常时,方法就会创建一个描述该异常的对象,将这个异常对象传递给运行时系统(runtime system)。这个对象叫做异常对象,它包含描述异常的信息、异常类型、出现异常是程序的状态等等。创建异常对象并将其交给运行时系统就叫做抛出异常。

    我们知道,方法的调用是一环扣着一环的,来自相同或者不同对象的方法调用形成一个链条,如下图:


    这个方法链就叫做调用栈(call stack)。而栈踪迹(stack trace)提供更多异常的信息,如当前线程的执行历史,异常发生时一个类列表和方法列表。我们常用printStackTrace( )方法或者printStackTrace(PrintStream)、printStackTrace(PrintWriter)来打印栈踪迹。异常抛出后,沿着这个调用栈的反方向依次查找能够处理此类型异常的异常处理代码(exception handler)。如下图所示:


    方法可以选择自己处理异常,也可以继续传递异常,甚至可以重新抛出异常。无论哪种方式,异常总会在某个点被捕捉并处理,如果所有方法都没有对异常进行处理,程序就终结。异常可以由虚拟机生成,也可以通过代码手动生成。虚拟机抛出的异常一般与语言规则(如除数为0)或者运行环境相关(比如内存溢出)的基础性错误有关,而手动抛出的异常一般用于向方法的调用者报告一些错误条件(如参数范围不对)。

    2. 两种异常处理方式

    异常抛出后,java提供2种方式对其进行处理。一种是使用try语句捕获异常并对异常进行处理,通过try、catch、finally这三个关键字来实现。另一种是使用关键字throws在方法声明时指定(specify)它可能抛出的异常类型。需要指出的是,并不是所有的异常都必须被处理或者指定,为了理解为什么是这样,我们有必要学习一下异常的类型。

    3. 异常类型

    所有的异常都是内置的Throwable类的子类。所以,虚拟机抛出的所有异常类型必须是Throwable及其子类的实例,使用throw。throws抛出的异常也必须这样,catch子句中的参数也必须是Throwable类及其子类的实例。Throwable有两个直接子类,Exception和Error。Exception有一个重要子类是RuntimeException。基于这样的继承关系,我们把异常分为三类:

    3.1 error

    这种类型的错误一般是程序之外的,而且很难预测和恢复。例如,程序成功打开了一个文件准备读取内容,但是由于硬件或者其他因素导致无法成功读取文件内容,这时候会抛出一个java.io.IOError。我们可以选择处理这种类型的异常,以提醒用户出现什么问题,也可以打印堆栈然后退出。这种类型的异常有Error及其子类来表示。我们可以不处理(捕捉或者指定)这类异常,通常也无法处理(因为不可预测),一般由虚拟机抛出,比如堆栈溢出就是一种error。

    3.2 runtime exception

    这类异常是程序自身导致的,通常有程序bug引起,比如创建Filereader对象时,我们传递了文件名给构造器,但是如果由于程序本身的原因导致传递null给构造器,这时候程序会抛出NullPointerException。程序可以捕捉这类异常,但是更有意义的做法也许是找出bug,修正程序。这类异常有RuntimeException及其子类表示,java不强制要求对这种类型的异常进行处理。

    error和runtime exception合起来称为unchecked exception,之所以这么称呼,是因为编译器不检查方法是否处理或者抛出这两种类型的异常。因此编译期间出现这种类型的异常也不会报错,所以我们可以不处理这些异常。而是由虚拟机提供默认的处理程序。

    3.3 checked exception:

    除了error和runtime exception这两种类型的异常外,其他的异常都称为checked 异常,优秀的程序必须预测到这些异常并从中恢复过来。再次以读取文件为例,加入现在的文件名是由用户输入的,正常情况下我们假设用户输入的文件存在并且可读的,然后程序正常运行。但是用户完全有可能输入一个不存在的文件名,这时候程序抛出FileNotFoundException,好的程序必须捕捉这类异常,然后提醒用户。对于这种类型的异常,我们的代码必须处理(try)或者抛出(指定)异常(throws)。

    4. 使用try catch finally处理异常

    对于checked类型异常,我们要么对它进行处理要么在方法头使用throws抛出。这一部分介绍第一种方法。try语句一般结构如下代码所示:

                    try {
    			// code could throw an exception
    			// risky code
    		} catch (IOException name) {
    
    		} catch (Exception name) {
    			// do something with exception
    		} catch (Throwable name) {
    			// do
    		} finally {
    			// clean up
    
    		}
    

    4.1 try:

    首先把可能抛出异常的代码块放在try语句当中,当然你可能把可能抛出unchecke异常甚至不会抛出异常的代码放进try语句中。

    4.2 catch

    紧接着是一个或者多个的catch语句,catch语句的参数为可能抛出的异常类型,catch语句用于处理异常。将抛出的异常类型与catch参数中的类型进行匹配,如果符合,则执行匹配的catch语句。所谓匹配,就是看能否将抛出的异常对象赋值给参数中异常类型的变量。执行完匹配的catch语句之后,其他catch语句就会被忽略掉。这跟switch语句中的case情况不一样,case语句中如果没有break,则会继续执行下一个case。在catch语句中可以做很多工作,从简单地输出信息,或者提醒用户做出决定,甚至使用链式异常将异常传递给更高一级的异常处理程序。

    关于catch有几点需要说明:1)参数的异常类型必须是Throwable类或者其子类。2)从上往下的catch语句,其参数类型必须按照从子类到父类顺序,因为一旦匹配到一个类型,catch语句捕获这个超累及其所有子类的异常,然后忽略往后的catch,也就意味着排在后面的子类用于不会到达,java中不可到达的代码被认为是错误的。3)可以有一个或者多个catch语句,甚至如果有finally语句的情况下,可以没有catch语句。 


    想要捕获多个异常,可以使用多个catch语句,JDK7以后提供了另外一种方式:多重捕获(multi-catch)。其格式如下:

    catch(ExceptionType1 | ExceptionType2 exception) { ... }

    每个异常类型用“|”分隔开,需要注意的是,使用这种方式的catch时,catch参数被自动设为final,因此不能赋予新值。下面是一个例子:

    catch (IOException|SQLException ex) {
        logger.log(ex);
        throw ex;
    }


    4.3 finally

    finally中的代码总是会被执行,除非在执行try或者catch语句时虚拟机退出(System.exit(1)),因此可以在finally里面放置一些收尾工作的代码(clean up),诸如关闭文件等。这样,即使执行try或者catch语句的时候遇到break、return、continue,finally的代码块依然会被执行(在方法返回之前执行)。需注意的是,如果执行try或者catch语句的线程被打断(interrupted)或者被杀死(killed),finally语句就不会执行。当操作文件或者其他流的时候,在finally关闭流是一种不错的方式。当然也可以使用Java 7以后带资源的try。

    finally语句不是必须的,也就是说try catch finally有三种组合:1)try catch finally 2) try catch 3)try finally。  

    4.4 几点说明:

    1)try语句中可能出现的异常,可以在catch语句中全部捕获处理,也可以只捕获处理一部分另外的留给throws处理。甚至可以全部不捕获,全部交由throws处理,只在finally中做一些clean up工作。

    2)如果try中没有异常抛出,则不执行任何catch语句。如果出现在catch参数中生命的异常类型,则执行对应的catch语句,忽略其他语句。如果抛出了catch中没有声明的异常,会在throws中抛出。finally总会被执行。

    3)try和catch语句中定义的变量都是局部变量,语句块结束之后就会消失,因此如果想在后续继续使用变量,要在try语句之前声明。

    4)如果在try block和finally block中都执行return语句,那么最终返回的是finally block的return值。例如下面的方法:

    	public static int go(int choice) {
    
    		try {
    
    			if (choice == 1)
    				System.out.println("Hello " + "Your name");
    			else if (choice == 2)
    				System.out.println("1 / 0 =  " + 1 / 0);
    			else if (choice == 3)
    				return 3;
    			else if (choice == 4)
    				System.exit(1);
    			else if (choice == 5)
    				System.out.println("1 / 0 =  " + 1 / 0);
    			else if (choice == 6)
    				return -1;
    		} catch (NumberFormatException e) {
    			System.out.println("Number Format Exception occurred");
    		} finally {
    			System.out.println("Goodbye from finally block");
    			if (choice == 5)
    				return 5;
    			if (choice == 6)
    				return 6;
    		}
    		return 0;
    	}
    如果choice=6,则在try语句中返回-1,在finally中返回6,最终返回的是6.

    5)如果一个没有被捕获的异常出现,并且从finally block中return,那么这个没有被捕获的异常会被丢掉。比较上面例子中的choice=2和5.2和5它们都抛出ArithmeticException(unchecked),但是如果choice=2,finally block不会执行return语句,所以异常会被抛出。而如果choice=5,那么finally block将执行return 5;语句,所以异常被丢掉,不会抛出。(可以运行验证)

    5. 嵌套try和带资源的try

    5.1 嵌套try语句:

    一条try语句可以嵌套在两外一条try语句中,例如:

    try {
    			// code could throw an exception
    			// risky code
    			//System.exit(1);
    			try {
    				
    			} catch (IndexOutOfBoundsException | Error e) {
    				// do something
    			}
    			
    			throw new IOException();
    		} catch (IOException name) {
    			// do something with exception
    			// nested try
    			try {
    				
    			} catch (RuntimeException e) {
    				
    			}
    		} catch (Throwable name) {
    			// do
    		} finally {
    			// clean up
    			System.out.println("clean up");
    			try {
    				
    			} catch (Throwable t) {
    				
    			}
    
    		}
    
    	}
    使用嵌套try的时候,尤其要注意catch参数类型顺序的问题,否则容易出现不可到达的代码。另外有一种比较隐蔽的嵌套try。比如在一个try语句中调用另外一个方法,而这个方法内部又有一条try语句。方法中的try语句会被嵌套在外层的try语句中。如果出现的异常在内层的try语句中没有被捕获,则会被传递到外层try语句。

    嵌套的try语句执行时,每当遇到一个try语句,就会将异常的上下文信息压入堆栈,如果内层try没有捕获某一出现的异常,堆栈就会弹出该try语句,检查下一条try语句的catch语句,知道检查完所有try语句,如果没有匹配的catch语句,虚拟机会处理该异常。

    5.2 带资源的try语句

    这里的资源(resource)是指程序使用完后必须关闭的对象。更具体地,资源是指实现了java.lang.AntoCloseable接口的类的对象。因为java.io.Closeable接口继承自AutoCloseable接口,所以实现了Closeable接口的类的对象都可以作为资源。AutoCloseable接口中的close()方法抛出Exception类型的异常,而Closeable()接口的抛出的是IOException类型,因此更加具体。try-with-resource确保使用的资源在try语句的结尾总会被关闭。其一般结构如下:

    try(resource-specification) {

      //use the resouce }

    其中,resource-specification用来声明和初始化资源。例如,

    static String readFirstLineFromFile(String path) throws IOException {
        try (BufferedReader br =
                       new BufferedReader(new FileReader(path))) {
            return br.readLine();
        }
    }
    声明和初始化了一个资源br,这个变量默认为final,也就是无法对其修改,不能赋给它新的值。使用带资源的try语句之后,不管try语句是正常结束还是出现异常而结束,br都会被关闭。如果带有catch和finally语句,将在catch和finally语句执行之前关闭文件。在Java 7以前,上面代码可能修改为下面这样的:

    static String readFirstLineFromFileWithFinallyBlock(String path)
                                                         throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(path));
        try {
            return br.readLine();
        } finally {
            if (br != null) br.close();
        }
    }
    在上面的代码中,如果readLine()和close()方法都抛出异常,那么readFirst...FinallyBlock()方法将会抛出来自close()方法的异常。相反地,在第一个例子中使用try-with-resource,如果try block(readLine)和try语句(不太明确?)同时抛出异常,那么来自readLine()方法的异常将会被ReadFirst...File抛出,来自try-with-resource的异常将会被挂起。这个挂起的异常在Java7以后可以被提取(通过Throwable定义的getSuppressed()方法)。

    可以声明一个或者多个资源,中间用分号;隔开,如下例子:

    try (
            java.util.zip.ZipFile zf =
                 new java.util.zip.ZipFile(zipFileName);
            java.io.BufferedWriter writer = 
                java.nio.file.Files.newBufferedWriter(outputFilePath, charset)
        ) {...}
    try block结束之后,这两个资源都会被关闭,被关闭的顺序与它们创建时候的顺序相反,即先关闭writer,再关闭zf。如果在try block中抛出异常,并且在try-with-resouce 语句中也抛出两个异常(调用close()方法时),那么try block的异常会被抛出,而带资源的try语句抛出的异常被挂起,我们可以通过调用try block抛出的异常对象的getSupressed()方法获得这两个挂起的异常,这个方法返回一个Throwable数组,代表被挂起的异常。


    5.3 异常挂起

    // todo

    6. 创建自己的异常类、throw抛出

    如果想要创建自己的异常类型,只需要定义Exception的子类,并且不需要事先任何内容即可作为异常。由于Exception继承了Throwable类,所以可以直接继承或者重写Throwable中的类的方法,例如toString()、getMessage()、printStackTrace()等等。默认的toString方法显示异常的名称,然后冒号,然后是我们提供描述异常的信息。可以重写该方法以适应自己的要求。定义好自己的异常类后,可以将其应用到catch语句中的参数,使用throw关键字抛出异常对象,格式为:

    throw ThrowableInstance;

    例如,创建了一个自定义异常类叫MyException,那么可以如下抛出异常:

    throw new MyException("exception message");

    异常抛出后,执行流会立即停止,寻找匹配的catch语句。

    另外,也可以在catch语句中捕获异常之后,做些基本工作,比如输出日志等,然后再次将其抛出。如:

    catch(NullPointerException e) {

        Log.log("null pointer...") // do what you want

        throw e; // rethrow

    }


    7. 链式异常

    在程序中,我们常常用抛出另一个异常来作为异常处理,上面提到重新抛出异常的情况,我们甚至可以重新创建一个异常对象然后将其抛出。可以认为是第一个异常导致了第二个异常的产生,称为链式异常。Throwable类为链式异常提供了一些方法支持,如下:

    public Throwable initCause(Throwable cause);指定这个异常对象的背后异常,并返回该异常的引用。如果已经通过构造函数为异常指定引发异常(看接下去最后两个方法),就不能再使用initCause()方法。

    public Throwable getCause(); 返回异常的背后异常。如果背后不存在或者不知道,返回null。

    public Throwable(Throwable cause);在创建一个异常对象的时候就指定它的背后异常。

    public Throwable(String message, Throwable cause);跟上一个构造器一致,不过多加了描述信息。

    下面是一个链式异常的例子:

    try {
    
    } catch (IOException e) {
        throw new SampleException("Other IOException", e);//maybe do something first
    }
    catch语句捕获一个异常e后,将其作为另一个异常的背后异常(引发异常),然后抛出另一个新的异常。获取一个异常对象之后,还可以进行很多操作,可以使用预定义的printStackTrace()方法,但是如果我们想获得更加详细、更加符合我们要求的栈踪迹,可以获取更高栈踪迹信息,例如下面的代码:

    catch (Exception cause) {
        StackTraceElement elements[] = cause.getStackTrace();
        for (int i = 0, n = elements.length; i < n; i++) {       
            System.err.println(elements[i].getFileName()
                + ":" + elements[i].getLineNumber() 
                + ">> "
                + elements[i].getMethodName() + "()");
        }
    }
    调用异常对象的getStackTrace()方法,得到StackTraceElement数组,进而提取更多信息。下面的代码在异常发生时候使用java.util.logging包输出日志信息:

    try {
        Handler handler = new FileHandler("OutFile.log");
        Logger.getLogger("").addHandler(handler);
        
    } catch (IOException e) {
        Logger logger = Logger.getLogger("package.name"); 
        StackTraceElement elements[] = e.getStackTrace();
        for (int i = 0, n = elements.length; i < n; i++) {
            logger.log(Level.WARNING, elements[i].getMethodName());
        }
    }

    链式异常支持所需要的任意深度。


    8.使用throws处理checked异常

    8.1 throws

    如果方法可能引发自身不进行处理的异常,就必须指明这一行为,以便方法的调用者能够保卫他们自己防备方法导致的异常。(你不干可以,得告诉别人)。通过在方法声明中使用throws来指明这一点。格式如下:

    type mathod-name (parameter-list) throws exception-list {  ...  }

    exception-list是可能抛出的异常类型,之间使用逗号隔开。对于checked 类型的异常,如果不在方法中捕获处理异常,也不在方法声明中用throws指明可能抛出的异常,则不能通过编译。在Eclipse中,如果没有对checked异常进行,那么会提示你有2种方法可以解决,一种是try语句,另一种就是在方法声明中throws。正式一点的说法,Java的代码必须符合“Catch or Specify Requirement.”,要么catch,要么Specify。Catch就是使用try语句捕获并处理异常。Specify就是在方法声明中使用throws指明它可能出现的异常类型。不符合“catch or specify”要求的代码无法通过编译。

    8.2 throw and throws

    这两个关键字经常容易混淆,有必要区别一下。首先从形式(这两个关键词可以出现在代码什么地方)上看,throw可以出现在方法或者代码块当中(比如静态初始化块)。而throws只出现在方法的声明中,紧跟方法参数列表之后,在接口中声明方法的时候,必须加上需要的throws。throw一次只能抛出一个异常对象,而throws可以指明该方法可能抛出的多个异常类型,使用逗号分隔。

    从作用上看,throw是创建异常对象,然后将其抛出,它后面跟的是对象!,完成的是“throw”操作。而throws只是声明方法可能抛出的异常,它后面紧跟着是异常类型(type),完成的是“declare、specify”操作,具体的“抛出”动作由throw来完成。在Java中,把throws这一操作称为“specify”,也就是指明、声明的意思。它是用于高速方法的调用者,这个方法可能会抛出哪些异常,使得方法调用者能够(也必须)做适当的异常处理,尤其是checked异常。

    可以这么理解,如果把方法当做一个整体的话,throws在方法声明中指明该方法可能出现但是在内部又没有处理的异常(handler),指明的是异常类型。throws作为方法的“发言人”告知外界可能出现的异常类型。而至于它内部是否抛出,如何抛出,是在本类方法中抛出还是在子类方法中抛出,外界一概不知。甚至在方法内部抛出但是方法自己偷偷处理掉而不向外公开也是完全可以的。而完全具体的抛出动作,即创建异常对象并提交给运行时系统这一工作,则由默默无闻的throw来完成。throw在自己的世界里创建、抛出异常对象,自己能处理(想处理、愿意处理)就自己处理,是在不愿意趟浑水,则告诉方法声明让它告诉外界,让外界(方法调用者)自己去处理吧!

    throw可以作为控制权转移的另一种方式(其他方式有return、continue、break),throw也可以用于退出switch中的case。例如:

    int number = 5;
    switch(number){
                case 1:
                    throw new RuntimeException("Exception number 1");
                case 2:
                    throw new RuntimeException("Exception number 2");
            }
    
    


    另外,以try方式处理异常时,只能捕获在try block中可能抛出的异常。但是对于throws,可以抛出方法中不会出现的异常。之所以这么设计,是为了在子类的方法重写时允许抛出父类方法不会抛出的异常。[接下来这一段提到的异常都是特质checked异常]在继承中,子类重写(覆盖)方法时不能抛出父类方法没有抛出的异常,这里的抛出是指throws抛出,在子类方法内部抛出父类方法没有抛出的异常并且方法自己处理掉是可以的。原因在于,如果子类重写的方法throws父类方法没有throws的异常,当一个父类变量引用子类的对象的时候,调用这个重写的方法时,编译器检查的时候,会要求我们处理父类中抛出的异常,而不会强制要求我们处理子类中的异常,但是实际调用方法的时候,可能会抛出没有处理的异常,这是不允许的。而相反的,父类方法则可以抛出子类方法没有抛出的异常。这是“子类不能约束(restrict)父类”这一原则的一个例子。一个出现在父类方法的异常说明(throws)的异常类型,不一定会出现在子类的throws中。极端情况是我覆盖父类方法的时候,把方法体设为空,什么也不干,什么异常也不声明(throws)。不能基于throws来重载方法。值得注意的时,子类的构造器可以抛出任何类型的异常而不受父类的构造器限制,但是基本子类构造器throws语句必须包含父类throws语句中的所有checked异常类型!也就是说,对于非构造方法,声明抛出的checked异常类型只能减少不能增多,而对于构造器,checked异常类型的声明则只能多不能减少。而如果在不同的构造器中抛出不同类型的异常,如果在子类构造器中交叉调用了其他重载的父类构造器,也要throws相应的checked 异常。最后在强调一遍,这一段中说的异常类型都是指checked异常类型。这些规则对于unchecked异常不适用。


    9. 静态块与异常:

    9.1 初始化块处理异常

    假设我们现在我这么一个类:

    public class MyClass {
        private Random rand = new java.util.Random();
        private MegaString ms =
            new MegaString("Hello " + rand.nextInt(100));
        private int x = rand.nextInt(100);
        . . .
    }
    很显然,每当一个MyClass对象创建的时候,都会执行类MegaString的构造方法从而创建一个MegaString对象。如果MegaString没有使用throws抛出异常(也就是不会将异常传递到方法的调用者),那么一切安好。可是如果构造器throws异常呢,比如下面这样:

    class MegaString{
        public MegaString(String s) throws Exception {
            . . .
        }
    }
    那么MyClass的编译将无法通过,因为创建MegaString对象的时候可能会抛出checked异常,而异常没有被处理。如果我们把MegaClass的构造器抛出的是Error或者RuntimeException或者它们的子类,那么编译可以正常通过,因为java不强制要求除以unckecked异常。

    好了,假设构造器跑出了checked异常,那么怎么办?我们不允许将域的声明放到try语句中,一个解决办法就是将域的声明语句放进初始化块,如下所示:

            {
    		try {
    			MegaClass mg = new MegaClass();
    		} catch (Exception e) {
    
    		}
    	}
    这样就能正常编译。如果你在Eclipse中开发,并且没有在静态块中处理异常,你会发现Eclipse提示是这样的:Default constructor cannot handle exception type Exception thrown by implicit super constructor. Must define an explicit constructor。它说默认的构造器不能处理异常,必须显式定义构造器。也就是提醒我们,异常可以在构造器中进行处理(域的初始化工作本质上是在构造器中完成的?),是不是这样呢?假如我们为MyClass显式添加构造器,修改成下面这样:

    public class MyClass {
    	private Random rand = new java.util.Random();
    	private MegaClass ms = new MegaClass("Hello " + rand.nextInt(100));
    	private int x = rand.nextInt(100);
    
    	public MyClass() throws Exception {
    
    	}
    
    }
    那么这个类时可以通过编译。但是如果我想在处理异常而不是简单地将其throws呢?可以将初始化工作放在构造器中,如下:

    public class MyClass {
    	private Random rand = new java.util.Random();
    	private MegaClass ms;
    	private int x = rand.nextInt(100);
    
    	public MyClass() {
    
    		try {
    			ms = new MegaClass("Hello " + rand.nextInt(100));
    		} catch (Exception e) {
    
    		}
    
    	}
    
    }
    这样便可以对异常进行更复杂的处理。可是问题又来了,如果我们有多个构造器,那么我们必须在每个构造器中都进行异常处理,所以有没有什么办法可以把异常处理模块独立出来进而实现代码复用呢?有,就是我们前面用到的初始化块。每次创建一个对象(即调用构造函数时),初始化块都会被执行,可以粗略地理解为“相当于把静态块嵌入到每个构造器”,因此,代码复用完美实现。当创建对象的时候,初始化和初始化块按照它在代码中的顺序执行,比如在下面的例子:

    public class MyClass {
        private java.util.Random rand = new java.util.Random();
        private MegaString ms = null;
        {
            try { ms = new MegaString("Hello " + rand.nextInt(100)); }
            catch (Exception e) { . . . }
        }
        private int x = rand.nextInt(100);
        . . .
    }

    初始化工作顺序如下: 创建一个Random对象,赋给第一个域rand--->随机生成器获得第一个随机数,用于创建ms对象。--->随机生成器生成第二个随机数,赋给域x。

    9.2 静态初始化块

    如果我们把上面的域ms改成静态的,如下所示:

    public class MyClass {
        private static MegaString sms = new MegaString("Goodbye");
        //. . .
    }
    编译一样无法通过,而且也不能在构造器中处理异常了,因为这个域是静态的。当这个类被加载到虚拟机的时候,MegaString的构造器就会被调用用于创建新的实例,异常将被抛出,而此时根本没有MyClass类的对象存在,也就不可能在构造器中处理异常了。如果采用静态块呢,如下:

    public class MyClass {
    	private Random rand = new java.util.Random();
    	private static MegaClass ms;
    	private int x = rand.nextInt(100);
    
    	{
    		try {
    			ms = new MegaClass("Hello " + rand.nextInt(100));
    		} catch (Exception e) {
    
    		}
    
    	}
    
    }
    
    这个类时可以编译通过的。那么此时是怎么回事,载入MyClass的时候,静态域ms会被初始化为null。然后当一旦有MyClass的对象被创建,这个静态域就会被新的值覆盖。我们加入一些代码看看结果:

    public class MyClass {
    	private Random rand = new java.util.Random();
    	private static MegaClass ms;
    	private int x = rand.nextInt(100);
    
    	{
    		try {
    			ms = new MegaClass("Hello " + rand.nextInt(100));
    		} catch (Exception e) {
    
    		}
    
    	}
    	
    	public static void main(String... args) {
    		System.out.println("None object exist:" + MyClass.ms); //null
    		new MyClass();
    		System.out.println("1 object:" +  MyClass.ms.hashCode());
    		new MyClass();
    		System.out.println("2 objects:" +  MyClass.ms.hashCode());
    	}
    
    }
    
    运行上面程序的输出结果如下:

    None object exist:null
    1 object:19157736
    2 objects:29310343
    首先在创建任何对象之前输出静态域,此时可以看到ms为null。这就是载入MyClass类的时候进行的静态域初始化工作。创建一个对象之后,你会发现此时的ms不再是null,它是一个对象了,我们输出它的哈希码。然后再创建另一个对象,再输出ms,哈希码变了,也就是说跟之前的对象已经不是同一个对象了。因为创建第二个对象的时候,也执行了一遍初始化块代码,ms域被新值覆盖。这也许不是我们想要的结果,如果我们想让静态域只被初始化一次然后值保持不变呢。这时候静态初始化块闪亮登场。我们把代码稍作修改,如下:

    /**
     * @author Brandon B. Lin
     * 
     */
    
    public class MyClass {
    	private static Random rand = new java.util.Random();
    	private static MegaClass ms;
    	private int x = rand.nextInt(100);
    
    	static {
    		try {
    			ms = new MegaClass("Hello " + rand.nextInt(100));
    		} catch (Exception e) {
    
    		}
    
    	}
    
    	public static void main(String... args) {
    		System.out.println(MyClass.ms == null); // null
    		System.out.println("None object exist:" + MyClass.ms.hashCode());
    		new MyClass();
    		System.out.println("1 object:" + MyClass.ms.hashCode());
    		new MyClass();
    		System.out.println("2 objects:" + MyClass.ms.hashCode());
    	}
    
    }
    
    注意几个地方的修改,首先rand被改为static,因为要在静态初始化块中调用。然后在初始化块之前加个static,在输出形式上我们也稍作修改,运行输出结果如下:

    false
    None object exist:19157736
    1 object:19157736
    2 objects:19157736

    可以看到,即使没有实例被创建,域ms也不是null。而且往后无论多少对象被创建,也不会改变ms,输出结果中哈希码完全一样的。也就是说,静态初始化块跟静态域一样,是在类被载入虚拟机的时候执行一次初始化工作,而在创建对象的时候,不会执行静态初始化块。当类被载入时,静态元素的执行顺序也是按照他们出现的顺序进行,首先创建静态域rand,然后将ms初始化为null,然后执行静态初始化块,可以在静态初始化块的最开始(try语句之前)加入一行代码:System.out.println("before static initializer: " + MyClass.ms); 此时输出结果如下:

    before static initializer: null
    false
    None object exist:29310343
    1 object:29310343
    2 objects:29310343

    可以看到静态初始化块之前,ms为null。


    需要注意的一点是,初始化块(包括静态初始化块)必须正常退出(complete normally),比如我们在初始化块的最后一行加上一个throw语句,则无法通过编译。


    10. Throwable及相关类研究:

    10.1 Throwable简介

    首先Throwable是个类,而不是接口,虽然它的命名看起来很像接口。Throwable是Java中所有异常类型的超类,用于表示程序中出现的某个异常,提供一些使用方法,以便追踪异常情况。两个直接子类是Error和Exception。

    10.2 Throwable构造方法:

    异常可以由虚拟机抛出,也可以我们使用throw关键字抛出,抛出的异常类型都必须是Throwable的子类。为了创建一个异常对象,可以直接使用Throwable类进行实例化。Throwable提供四个构造函数,其中的两个指定异常的背后异常(引发异常),而另外2个则没有。如下:

    public Throwable(String message,  Throwable cause)
    第一个参数是描述异常的信息(detailed message),可以在异常抛出后通过getMessage()方法获得。第二个参数指定链式异常中的背后异常,也就是导致该异常对象产生的异常。如果在实例化的时候不指定背后异常,则变成如下构造器:

    public Throwable(String message)
    如果创建的时候没有指定背后异常,可以后面追加背后异常,调用Throwable类的initCasuse(Throwable)方法。也可以指定背后异常而不指定细节信息,得到下面的形式:

    public Throwable(Throwable cause)
    如果背后异常和细节信息都不想指定,也没有问题:

    public Throwable()
    简单明了,什么都没有。有些人可能什么都想要了,要把异常搞得复杂一点,没问题:

    protected Throwable(String message,
                        Throwable cause,
                        boolean enableSuppression,
                        boolean writableStackTrace)
    message/cause两个参数跟前面介绍的完全一样。enableSuppression用于设置能否挂起异常,主要在带资源的try语句中应用,具体的在下面的方法介绍。writableStackTrace设置能否写入堆栈,堆栈在异常发生的时候追踪方法列表等其他信息,具体下文相关方法介绍。

    10.3 设置和获取背后异常:

    如果在创建对象的时候没有使用cause参数指定背后异常,创建(由虚拟机或者代码)之后依然可以设置背后异常。使用initCause方法:

    public Throwable initCause(Throwable cause)
    这个方法最多只能被调用一次,将背后异常与当前异常关联起来,一般在构造器中调用或者在创建异常对象之后马上调用。它返回关联之后的当前异常(原来没有cause,调用该方法之后有了)。

    如果出现下面其中一种情况,那么这个方法将抛出IllegalStateException异常:

    1)如果创建该对象的时候已经指定背后异常,并且之前还没有调用过该方法;

    2)创建对象的时候没有指定异常,但是已经调用过一次该方法。

    也就是说,如果创建异常对象的时候指定了背后异常,那么这个方法一次不能调用。如果没有指定背后异常,最多只能调用一次(可以一次都不调用),否则将抛出IllegalStateException

    如果将异常本身作为背后异常,那么将出现IllegalArgumentException异常。异常本身不能作为自己的背后异常。

    可以设置背后异常,也就有相应获取异常的方法getCuase()

    public Throwable getCause()
    如果该异常没有指定背后异常,也就是创建对象的时候没有指定背后异常,创建之后也没用调用initCause指定背后异常,那么将返回null。

    如果背后异常存在,返回背后异常,这个背后异常可能是创建的时候指定的,也可能是创建之后再指定的。需要注意的是,返回null并不一定就代表背后异常不存在,可能背后异常存在但是不知道(unknown)。

    10.4 有关堆栈踪迹的方法:

    栈踪迹用于记录方法调用关系等其他信息,对于处理异常十分关键。Throwable类定义了好几个相关的方法:

    public Throwable fillInStackTrace()

    这个方法写入与该异常对象相关的栈踪迹,具体指当前线程的栈帧(stack frame)。如果在创建对象的时候将writableStackTrace参数设置为false,则该方法不执行什么操作,对栈踪迹没有影响。返回的是对当前异常的引用。我们来看看具体的一个例子:

    /**
     * @author Brandon B. Lin
     *
     */
    public class Rethrow {
    
    	public static void f() throws Exception {
    		System.out.println("方法f()抛出异常");
    		throw new Exception("我是来自f()的异常");
    	}
    	
    	public static void g() throws Exception {
    		try {
    			f();
    		} catch (Exception e) {
    			System.out.println("方法g()中輸出的堆棧信息");
    			for(StackTraceElement s:e.getStackTrace()) {
    				System.out.println(s.getMethodName());
    			}
    			throw e;
    		}
    	}
    	
    	public static void h() throws Exception {
    		try {
    			f();
    		} catch (Exception e) {
    			System.out.println("方法h()中輸出的堆棧信息");
    			for(StackTraceElement s:e.getStackTrace()) {
    				System.out.println(s.getMethodName());
    			}
    			throw (Exception)e.fillInStackTrace();
    		}
    	}
    	
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		try {
    			g();
    		} catch(Exception e) {
    			System.out.println("方法main()中輸出的堆棧信息");
    			for(StackTraceElement s:e.getStackTrace()) {
    				System.out.println(s.getMethodName());
    			}
    		}
    		
    		try {
    			h();
    		} catch(Exception e) {
    			System.out.println("方法main()中輸出的堆棧信息");
    			for(StackTraceElement s:e.getStackTrace()) {
    				System.out.println(s.getMethodName());
    			}
    		}
    
    	}
    
    }
    
    首先定义一个抛出Exception异常的方法f(),然后分别在g()和h()方法中调用f()方法,唯一的区别就是在g()方法中,只是简单地把异常对象重新抛出。但是在h()方法中,调用了异常对象的fillInStackTrace()方法,使得异常对象的对栈踪迹发生变化。然后在main方法中分别调用g和h,并且在方法中打印异常的堆栈踪迹,即调用的方法列表,然后把main方法中的输出和g和h方法中的输出做比较,最后输出结果如下(添加了分隔线):

    方法f()抛出异常
    方法g()中輸出的堆棧信息
    f
    g
    main
    ===================
    方法main()中輸出的堆棧信息
    f
    g
    main
    ===================
    方法f()抛出异常
    方法h()中輸出的堆棧信息
    f
    h
    main
    ===================
    方法main()中輸出的堆棧信息
    h
    main
    
    比较可以看到,在没有调用fillInStackTrace()方法重写堆栈踪迹的情况下,f()方法和main()输出的堆栈踪迹是一样的。

    而如果调用了这个方法重写堆栈踪迹,则调用fillInStackTrace方法的这一行成为了异常新的堆栈踪迹起点,有关原来异常发生点的信息全部丢失,所以输出方法列表的时候只输出h和main。因此,把握好异常抛出点很重要,是简单地将原来异常对象抛出,还是调用fillInStackTrace方法覆盖堆栈,还是抛出一个全新的异常对象,其堆栈踪迹都不一样。


    如果想获取堆栈踪迹的信息,调用下面的方法:

    public StackTraceElement[] getStackTrace()
    该方法返回对栈踪迹的数组。每个对栈踪迹代表一个堆栈帧,即对应一个方法调用,与出现异常之前调用的最后一个方法相关堆栈踪迹存在该数组的第一个元素,第一个元素对应的方法,通常都是创建和抛出异常对象的方法。通过调用StackTraceElement的方法,可以获取每个堆栈踪迹相关的信息,例如方法名称。对获取的数组进行赋值重写,不会影响该方法的后续调用,也就是该方法返回的只是一个副本。

    public void setStackTrace(StackTraceElement[] stackTrace)
    设置堆栈踪迹,一般用于特殊的程序(RPC Framework),允许对默认的堆栈踪迹(调用fillInStackTrace()方法时写入)进行重写。调用getStackTrace或者PrintStackTrace时将使用这里设置的对栈踪迹。如果传入的参数为null,或者参数中的某一数组元素为null,抛出NullPointerException异常。处理异常时,我们经常输出堆栈踪迹,使用的是下面的方法:

    public void printStackTrace()
    public void printStackTrace(PrintStream s)
    public void printStackTrace(PrintWriter s)
    将堆栈踪迹写入到指定的输出流中,如果没有指定参数,输出到标准错误流,即System.err。

    10.5 挂起异常:

    在带资源的try语句中,我们简单提到了异常挂起。下面我们深入地看一下:

    在常规的try语句try { ... }中,虽然try block中可能抛出的异常有多个,但是在实际的运行中,只有一个异常对象会被抛出(因为一旦某个异常对象被抛出,try block中往后的语句就不会被执行)。但是在带资源的try语句:try(resouce1:resource2){ ... }中,编译器对这个try语句生成了隐式的finally,并且这个用于关闭资源的finally会在catch和显示的finally执行之前执行,因此从整体上看,try可能会抛出多个异常,因此必须做出选择,此时编译器选择将try-with-resouce-statement(也就是隐式的、在catch之前执行的、finally语句)中抛出的异常挂起(suppressed,或者成为沪市ignore),而将try block中的异常抛出。于是出现了挂起异常这个概念。

    public final void addSuppressed(Throwable exception)
    上面的这个方法就是将try-with-resource statement抛出的异常挂起,指定给try block抛出的异常,这个方法通常被try-with-resource statement自动、隐式地调用,例如看看前面的一个例子:
    static String readFirstLineFromFile(String path) throws IOException {
        try (BufferedReader br =
                       new BufferedReader(new FileReader(path))) {
            return br.readLine();
        }
    }
    例子中的带资源的try语句在关闭br的时候可能会产生异常,记为ex1. try block中的readLine()也可能产生异常,记为ex2. 编译器通过调用ex2.addSuppressed(ex1)将带资源的try语句抛出的异常挂起,而将ex2抛出。

    传统的try语句可能会这么处理:

    static String readFirstLineFromFileWithFinallyBlock(String path)
                                                         throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(path));
        try {
            return br.readLine();
        } finally {
            if (br != null) br.close();
        }
    }

    这种情况下编译器将try block中产生的异常捕获(不会挂起),而将finally产生的异常抛出。为了验证这一点,我们设计一个这样的类:

    /**
     * @author Brandon B. Lin
     * 
     */
    public class DirtyResource implements AutoCloseable {
    
    	/**
    	 * access resouce
    	 * 
    	 * @throws RuntimeException
    	 *             no matter how you call this method
    	 */
    	public void accessResource() {
    		throw new RuntimeException("runtime exception from accessResource()");
    	}
    
    	/**
    	 * 
    	 * @throws Exception
    	 */
    	@Override
    	public void close() throws Exception {
    		throw new NullPointerException("I am nullpointer Exception from close()");
    	}
    
    }

    然后以传统的try语句使用这个类:

    public class Test1 {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		try {
    			memberFunction();
    		} catch (Exception ex) {
    			System.err.println("Exception encountered: " + ex.toString());
    			final Throwable[] suppressed = ex.getSuppressed();
    			if (suppressed.length > 0) {
    				System.err.println("There are " + suppressed.length
    						+ "suppressed exception");
    				for (Throwable throwable : suppressed) {
    					System.err.println(throwable.toString());
    				}
    			}
    		}
    
    	}
    
    	private static void memberFunction() throws Exception {
    		DirtyResource resource = new DirtyResource();
    		try {
    			resource.accessResource();
    		} finally {
    			resource.close();
    		}
    	}
    
    }
    

    输出结果为:

    Exception encountered: java.lang.NullPointerException: I am nullpointer Exception from close()
    可以看到,抛出的是来自close()方法的异常,而来自accessResource方法的异常没有抛出,也没有挂起,只是把它“丢失”。现在修改一下代码,将来自accessresource方法的异常挂起:

    /**
     * @author Brandon B. Lin
     * 
     */
    public class Test2 {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		try {
    			memberFunction();
    		} catch (Exception ex) {
    			System.err.println("Exception encountered: " + ex.toString());
    			final Throwable[] suppressed = ex.getSuppressed();
    			if (suppressed.length > 0) {
    				System.err.println("There are " + suppressed.length
    						+ " suppressed exception");
    				for (Throwable throwable : suppressed) {
    					System.err.println(throwable.toString());
    				}
    			}
    		}
    
    	}
    
    	private static void memberFunction() throws Exception {
    		Throwable th = null;
    		DirtyResource resource = new DirtyResource();
    		try {
    			resource.accessResource();
    		} catch (Exception ex) {
    			th = ex;
    		} finally {
    			try {
    				resource.close();
    			} catch (Exception e) {
    				if (th != null) {
    					e.addSuppressed(th);
    					throw e;
    				}
    			}
    
    		}
    
    	}
    }
    输出为:

    Exception encountered: java.lang.NullPointerException: I am nullpointer Exception from close()
    There are 1 suppressed exception
    java.lang.RuntimeException: runtime exception from accessResource()
    

    我们最后使用带资源的try语句来操作一下:

    /**
     * @author Brandon B. Lin
     * 
     */
    public class Test3 {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		try {
    			memberFunction();
    		} catch (Exception ex) {
    			System.err.println("Exception encountered: " + ex.toString());
    			final Throwable[] suppressed = ex.getSuppressed();
    			if (suppressed.length > 0) {
    				System.err.println("There are " + suppressed.length
    						+ " suppressed exception");
    				for (Throwable throwable : suppressed) {
    					System.err.println(throwable.toString());
    				}
    			}
    		}
    
    	}
    
    	private static void memberFunction() throws Exception {
    		try (DirtyResource d = new DirtyResource()) {
    			d.accessResource();
    		}
    	}
    }
    
    此时我们没有手动将来自accessResource方法的异常挂起,但是调用getSuppressed方法的时候,依然能得到挂起异常,说明编译器已经自动、隐式地帮我们把异常挂起了。

    输出为:

    Exception encountered: java.lang.RuntimeException: runtime exception from accessResource()
    There are 1 suppressed exception
    java.lang.NullPointerException: I am nullpointer Exception from close()
    

    以上例子参考:http://howtodoinjava.com/2013/03/13/suppressed-exceptions-in-java-7/

    添加完挂起异常(通常是隐式、自动的,也可以手动添加挂起异常)之后,就可以调用getSuppressed方法获取这些挂起异常:

    public final Throwable[] getSuppressed()
    返回的是一个代码挂起异常列表的Throwable数组。如果创建异常对象时将enableSuppression设为false或者没有异常被挂起,将返回空数组而不是null。

    10.6 其他方法:

    除了上面介绍的,还有用于提取细节信息的方法、toString方法。

    public String getMessage()
    public String getLocalizedMessage()
    public String toString()
    对于toString,Throwable提供了默认的实现方式,输出格式为:     异常对象的类型:细节信息   可以重写该方法获取你想要的输出格式。

    11.assert:断言

    Java1.4 加入了断言的概念,它是用于测试某种假设(presumed)的、推测的状态(state)是否确实存在。

    || 如果状态跟假设的不符,那么会抛出AssertionError。

    || 断言不是用于测试可以预期的值。

    断言基本格式如下:

    assert(condition)[: messageExpression]

    其中方括号部分可以省略,这个消息将会传递给AssertError的构造器。还是非常抽象难懂,举个例子,我们使用一个第三方类库中的方法,该方法声明它将返回一个0-1之间的double值,但是我们想确认是否的确如此(断言)!代码如下:

    public class AssertionTest {
     
      public static void main(String[] args) {
        double value = thirdPartyFunction();
        assert (value >= 0 && value < 1) :
           " thirdPartyFunction value " + value + " out of range";
        System.out.println("Value is " + value);
      }
     
      public static double thirdPartyFunction() {
        return 5.0;
      }
    }
    如果断言的条件为false,也就是方法返回的值不在0-1之间,那么将抛出AssertError。


    断言用于代码调试,在正式产品中一般将会关闭。想要运行含有断言的版本,使用java -ea ClassName开启 或者用-enableassertion,关闭使用参数-da。注意断言不能对程序的正常运行产生副作用。

    12. 常见的预定义异常

    Java库中定义了许多异常类型,下面简要介绍一些。

    12.1 RuntimeException子类

    (在java.lang中定义的、unchecked)

    》ArithmeticException:算数错误,例如除数为0.

    》ArrayIndexOutofBoundsException:数组索引越界。(编译期间不会检查是否越界)

    》StringIndexOutOfBoundsException:超出字符串边界

    》IndexOutOfBoundsException:某些类型索引越界,例如数组、String索引、Vector索引。ArrayIndexOutOfBoundsException是它的子类。

    》ArrayStoreException:使用不兼容的类型为数组袁术赋值,例如:

    Object[] strings = new String[3]; string[1] = new Integer(1);

    》ClassCastException:无效的类型转换,例如:

    Object o = new String("TT");   System.out.println((Integer)o);

    》EnumConstantNotPresentException:试图使用用定义的枚举值

    》IllegalArgumentException:使用非法调用参数。

    》NegativeArraySizeException:使用负数创建数组

    》NullPointerException:非法使用空引用

    》UnsupportedOperationException:遇到不支持的操作

    》NumberFormatException:字符串到数值格式的无效转换


    12.2 java.lang中定义的checked异常

    》ClassNotFoundException:类未找到

    》CloneNotSupportedException:试图克隆没有实现Cloneable接口的对象

    》InterruptedException:一个线程被另一个线程中断

    》InstantiationException:试图为抽象类或者接口创建对象

    》NoSuchFieldException:请求的域不存在

    》NoSuchMethodException:请求的方法不存在。


    ----------------------------------------------------------

    后记:几经修改,总算完成了一个比较完整的版本,虽然对于Java的异常来说,也许这知识皮毛。但是至少对异常有个比较全面的认识。学习最重要的大概就是思考和总结吧,加油。


    版权所有,转载请注明出处!

    展开全文
  • Java异常总结

    千次阅读 多人点赞 2016-09-06 19:40:54
    java异常的总结,包括java异常处理的关键字,java异常捕获的格式,常见的java异常情况,和java异常处理的原则和技巧

    Java异常总结

     

    一.java异常类结构体系图

     



    二.java异常基本概念

     

    (一)Throwable:异常和错误的基类,提供了错误堆栈实现等一系列方法。 两个直接子类:Error & Exception

     

    (二)两个子类区别:

         1. Error: 程序不应该捕捉的错误,应该交由JVM来处理。一般可能指非常重大的错误。这个错误我们一般获取不到。

         2. Exception:程序中应该要捕获的错误。这个异常类及它的子类是我们需要学习获取的。

       (1)RuntimeException:运行期异常,是Exception的子类,但不需捕捉的异常超类,但是实际发生异常时,还是会蹦的,只是编译时没有报错而已。比如除数为零,数组空指针等等,这些都是在运行之后才会报错。

       (2)除了RuntimeException类和它的子类,其他类都被定义为Checked类,是需要显式处理可能出现的异常,否则编译就报错了。Checked类主要包含:IO类和SQL类的异常情况,这些在使用时经常要先显示处理异常(使用throws或try   catch捕获)。

     


    三.java常见的异常(最好记住)

    (一)Exception 异常层次结构的根类

    (二)ArithmeticException 算术错误情形,如以零作除数

    (三)ArrayIndexOutOfBoundsException  数组小于或大于实际的数组大小

    (四)NullPointerException  尝试访问null对象成员

    (五)ClassNotFoundException   不能加载所需的类(常见于多态中向下转型)

    (六)InputMismatchException   欲得到的数据类型与实际输入的类型不匹配

    (七)IllegalArgumentException 方法接收到非法参数

    (八)ClassCastException  类强转异常。假设有类A和B(A不是B的父类或子类),O是A的实例,那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。

    这些常见的异常都是Runtime异常,发送这些异常时,我们都要知道是怎么修改。当然还有其他的异常需要记住的,比如IO异常,上面只是一些比较基础的。

     


    四.Java异常处理的格式

    (一)java异常处理的关键字有5个:try、catch、finally、throw、throws。

    (二)java异常捕获的格式。程序没有出现异常时,不会执行catch。
          1.try-catch
    每次出现异常,都会去catch匹配,如果能匹配到,程序执行catch里面的代码
    如果没有匹配到,程序抛出异常退出
         2.try-catch-catch...
    如果出现异常,那么会一个一个去匹配catch子类在前,父类在后,否者出现编译错误
        3.try-finally
    finally是程序必须执行的一个代码块,除了一种情况System.exit(0);
        4.try-catch-finally

     5.throw new Exception(“输入错误的提示!”);

    这句语句也要放在try-catch语句模块里面或者放在throws的方法体里面。这种情况可用在获取的值,不符合自己的期望,比如要求输入不大于10的数,获取到大于10的数时,主动抛出异常,提示用户输入错误。但是一般不建议使用,因为使用异常捕获还要经过异常机制处理,会花费时间和内存,降低程序效率。

       (三)throw和throws的区别

    这只是有点相似的关键字,并没有任何关联,要学会区分。

    throw是用在方法体里面的,一般是放在判断情况的后面,手动抛出异常。

    throws只能用在需要捕获异常的方法的方法名的括号后面使用。

     

     

     

     

    四.Java异常处理的原则和技巧

     

        (一)避免过大的try块。不要把不会出现异常的代码放到try块里面,尽量保持一个try块对应一个或多个异常。
        (二)细化异常的类型。不要不管什么类型的异常都写成Excetpion。
        (三)catch块尽量保持一个块捕获一类异常。不要忽略捕获的异常,捕获到后要么处理,

    要么转译,要么重新抛出新类型的异常。
        (四)不要把自己能处理的异常抛给别人。
        (五)不要用try...catch参与控制程序流程。异常控制的根本目的是处理程序的非正常情况。

    所以像那些可以预料的错误,尽量在执行之前就做好相应的处理,

    比如除数为零或空指针问题,要做事前判断再运行程序。


    习题:
    1、写一个登录(login)的方法,方法中有两个String类型形参,分别是账户名密码,校验用户账户名密码
    ,账户名不是"liwenzhi"或者密码不是"123456",则该方法向外抛出一个异常,

    异常信息提示文字是“输入账户或者密码不正确”。


    这题考察的是throw的使用:参考答案代码如下

    public class Login {
    	public static void main(String[] args) throws Exception {
    		Scanner scanner = new Scanner(System.in);
    		boolean isLoginSuccess = true;// 用户是否登陆成功
    		System.out.println("请您的用户名:");
    		String inputName = scanner.next();// 获取用户输入的姓名
    		System.out.println("请输入6位数的密码:");
    		String inputCode = scanner.next();// 获取用户输入的密码
    		scanner.close();
    		if (!"liwenzhi".equalsIgnoreCase(inputName)
    				|| !"123456".equalsIgnoreCase(inputCode)) {
    			isLoginSuccess = false;
    			throw new Exception("你输入的账户名或密码不对!");
    		}
    
    		if (isLoginSuccess) {
    			System.out.println("******恭喜你登陆成功******");
    		} else {
    			System.err.println("******你的账号已经被锁定******");
    		}
    	}
    }


     

    展开全文
  • JAVA异常整理

    千次阅读 2017-02-17 15:13:33
    一、Java 常见异常种类 Java Exception: 1、Error  2、Runtime Exception 运行时异常 3、Exception  4、throw 用户自定义异常 Java异常类层次结构图:  图1 Java异常类层次结构图 在 Java 中,...

    一、Java 常见异常种类


    Java Exception:

    1、Error 
    2、Runtime Exception 运行时异常
    3、Exception 
    4、throw 用户自定义异常

    Java异常类层次结构图:




      图1 Java异常类层次结构图


    在 Java 中,所有的异常都有一个共同的祖先 Throwable(可抛出)。Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。


           Throwable: 有两个重要的子类:Exception(异常)和 Error(错误),二者都是 Java 异常处理的重要子类,各自都包含大量子类。


           Error(错误):是程序无法处理的错误,表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关,而表示代码运行时 JVM(Java 虚拟机)出现的问题。例如,Java虚拟机运行错误(Virtual MachineError),当 JVM 不再有继续执行操作所需的内存资源时,将出现 OutOfMemoryError。这些异常发生时,Java虚拟机(JVM)一般会选择线程终止。

            这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时,如Java虚拟机运行错误(Virtual MachineError)、类定义错误(NoClassDefFoundError)等。这些错误是不可查的,因为它们在应用程序的控制和处理能力之 外,而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说,即使确实发生了错误,本质上也不应该试图去处理它所引起的异常状况。在 Java中,错误通过Error的子类描述。


           Exception(异常):是程序本身可以处理的异常。

           Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如,若试图使用空值对象引用、除数为零或数组越界,则分别引发运行时异常(NullPointerException、ArithmeticException)和 ArrayIndexOutOfBoundException。


       注意:异常和错误的区别:异常能被程序本身可以处理,错误是无法处理。


       通常,Java的异常(包括Exception和Error)分为可查的异常(checked exceptions)和不可查的异常(unchecked exceptions)


          可查异常(编译器要求必须处置的异常):正确的程序在运行中,很容易出现的、情理可容的异常状况可查异常虽然是异常状况,但在一定程度上它的发生是可以预计的,而且一旦发生这种异常状况,就必须采取某种方式进行处理。

          除了RuntimeException及其子类以外,其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它,也就是说,当程序中可能出现这类异常,要么用try-catch语句捕获它,要么用throws子句声明抛出它,否则编译不会通过。


         不可查异常(编译器不要求强制处置的异常):包括运行时异常(RuntimeException与其子类)和错误(Error)。

         Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。


           运行时异常:都是RuntimeException类及其子类异常,如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等,这些异常是不检查异常,程序中可以选择捕获处理,也可以不处理。这些异常一般是由程序逻辑错误引起的,程序应该从逻辑角度尽可能避免这类异常的发生。

          运行时异常的特点是Java编译器不会检查它,也就是说,当程序中可能出现这类异常,即使没有用try-catch语句捕获它,也没有用throws子句声明抛出它,也会编译通过。


           非运行时异常 (编译异常):是RuntimeException以外的异常,类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常,如果不处理,程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常,一般情况下不自定义检查异常



    二、异常处理机制


    在 Java 应用程序中,异常处理机制为:抛出异常,捕捉异常。


            抛出异常当一个方法出现错误引发异常时,方法创建异常对象并交付运行时系统,异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。


            捕获异常:在方法抛出异常之后,运行时系统将转为寻找合适的异常处理器(exception handler)。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时,即为合适 的异常处理器。运行时系统从发生异常的方法开始,依次回查调用栈中的方法,直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器,则运行时系统终止。同时,意味着Java程序的终止。

            对于运行时异常、错误或可查异常,Java技术所要求的异常处理方式有所不同。

            由于运行时异常的不可查性,为了更合理、更容易地实现应用程序,Java规定,运行时异常将由Java运行时系统自动抛出,允许应用程序忽略运行时异常。

           对于方法运行中可能出现的Error,当运行方法不欲捕捉时,Java允许该方法不做任何抛出声明。因为,大多数Error异常属于永远不能被允许发生的状况,也属于合理的应用程序不该捕捉的异常。

           对于所有的可查异常,Java规定:一个方法必须捕捉,或者声明抛出方法之外。也就是说,当一个方法选择不捕捉可查异常时,它必须声明将抛出异常。

            能够捕捉异常的方法,需要提供相符类型的异常处理器。所捕捉的异常,可能是由于自身语句所引发并抛出的异常,也可能是由某个调用的方法或者Java运行时 系统等抛出的异常。也就是说,一个方法所能捕捉的异常,一定是Java代码在某处所抛出的异常简单地说,异常总是先被抛出,后被捕捉的。

             任何Java代码都可以抛出异常,如:自己编写的代码、来自Java开发环境包中代码,或者Java运行时系统。无论是谁,都可以通过Java的throw语句抛出异常。

            从方法中抛出的任何异常都必须使用throws子句。

            捕捉异常通过try-catch语句或者try-catch-finally语句实现。

    总体来说,Java规定:对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。


    1)捕获异常:try、catch 和 finally


    1.try-catch语句


         在Java中,异常通过try-catch语句捕获。其一般语法形式为:

    try {  
        // 可能会发生异常的程序代码  
    } catch (Type1 id1){  
        // 捕获并处置try抛出的异常类型Type1  
    }  
    catch (Type2 id2){  
         //捕获并处置try抛出的异常类型Type2  
    }  


    关键词try后的一对大括号将一块可能发生异常的代码包起来,称为监控区域。Java方法在运行过程中出现异常,则创建异常对象。将异常抛出监控区域之 外,由Java运行时系统试图寻找匹配的catch子句以捕获异常。若有匹配的catch子句,则运行其异常处理代码,try-catch语句结束。

           匹配的原则是:如果抛出的异常对象属于catch子句的异常类,或者属于该异常类的子类,则认为生成的异常对象与catch块捕获的异常类型相匹配。


    需要注意的是,一旦某个catch捕获到匹配的异常类型,将进入异常处理代码。一经处理结束,就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。

          Java通过异常类描述异常类型,异常类的层次结构如图1所示。对于有多个catch子句的异常程序而言,应该尽量将捕获底层异常类的catch子 句放在前面,同时尽量将捕获相对高层的异常类的catch子句放在后面。否则,捕获底层异常类的catch子句将可能会被屏蔽。


    2. try-catch-finally语句


          try-catch语句还可以包括第三部分,就是finally子句。它表示无论是否出现异常,都应当执行的内容。try-catch-finally语句的一般语法形式为:


    try {  
        // 可能会发生异常的程序代码  
    } catch (Type1 id1) {  
        // 捕获并处理try抛出的异常类型Type1  
    } catch (Type2 id2) {  
        // 捕获并处理try抛出的异常类型Type2  
    } finally {  
        // 无论是否发生异常,都将执行的语句块  
    }  


    小结:


    try 块:用于捕获异常。其后可接零个或多个catch块,如果没有catch块,则必须跟一个finally块。
    catch 块:用于处理try捕获到的异常。
    finally 块:无论是否捕获或处理异常,finally块里的语句都会被执行。
    当在try块或catch块中遇到return语句时,finally语句块将在方法返回之前被执行。

    在以下4种特殊情况下,finally块不会被执行:

    1)在finally语句块中发生了异常。
    2)在前面的代码中用了System.exit()退出程序。
    3)程序所在的线程死亡。
    4)关闭CPU。


    3. try-catch-finally 规则(异常处理语句的语法规则):


    1)  必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块,但至少有一个块。
    2) 必须遵循块顺序:若代码同时使用 catch 和 finally 块,则必须将 catch 块放在 try 块之后。
    3) catch 块与相应的异常类的类型相关。
    4) 一个 try 块可能有多个 catch 块。若如此,则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配,如果异常对象为某个异常类型或其子类的实例,就执行这个catch代码块,不会再执行其他的 catch代码块
    5) 可嵌套 try-catch-finally 结构。
    6) 在 try-catch-finally 结构中,可重新抛出异常。
    7) 除了下列情况,总将执行 finally 做为结束:JVM 过早终止(调用 System.exit(int));在 finally 块中抛出一个未处理的异常;计算机断电、失火、或遭遇病毒攻击。


    4. 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语句块后的语句;


    图示try、catch、finally语句块的执行:




    2)抛出异常


          任何Java代码都可以抛出异常,如:自己编写的代码、来自Java开发环境包中代码,或者Java运行时系统。无论是谁,都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。


    1. throws抛出异常


    如果一个方法可能会出现异常,但没有能力处理这种异常,可以在方法声明处用throws子句来声明抛出异常。例如汽车在运行时可能会出现故障,汽车本身没办法处理这个故障,那就让开车的人来处理。

    throws语句用在方法定义时声明该方法要抛出的异常类型,如果抛出的是Exception异常类型,则该方法被声明为抛出所有的异常。多个异常可使用逗号分割。throws语句的语法格式为:


    methodname throws Exception1,Exception2,..,ExceptionN  
    {  
    }  

    方法名后的throws Exception1,Exception2,...,ExceptionN 为声明要抛出的异常列表。当方法抛出异常列表的异常时,方法将不对这些类型及其子类类型的异常作处理,而抛向调用该方法的方法,由他去处理。例如:


    import java.lang.Exception;  
    public class TestException {  
        static void pop() throws NegativeArraySizeException {  
            // 定义方法并抛出NegativeArraySizeException异常  
            int[] arr = new int[-3]; // 创建数组  
        }  
      
        public static void main(String[] args) { // 主方法  
            try { // try语句处理异常信息  
                pop(); // 调用pop()方法  
            } catch (NegativeArraySizeException e) {  
                System.out.println("pop()方法抛出的异常");// 输出异常信息  
            }  
        }  
      
    }  

    使用throws关键字将异常抛给调用者后,如果调用者不想处理该异常,可以继续向上抛出,但最终要有能够处理该异常的调用者。

    pop方法没有处理异常NegativeArraySizeException,而是由main函数来处理。


    Throws抛出异常的规则:


        1) 如果是不可查异常(unchecked exception),即Error、RuntimeException或它们的子类,那么可以不使用throws关键字来声明要抛出的异常,编译仍能顺利通过,但在运行时会被系统抛出。

        2)必须声明方法可抛出的任何可查异常(checked exception)。即如果一个方法可能出现受可查异常,要么用try-catch语句捕获,要么用throws子句声明将它抛出,否则会导致编译错误

        3)仅当抛出了异常,该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候,应该继续抛出,而不是囫囵吞枣。

              4)调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法,则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。



    例如:


    void method1() throws IOException{}  //合法    
       
    //编译错误,必须捕获或声明抛出IOException    
    void method2(){    
      method1();    
    }    
       
    //合法,声明抛出IOException    
    void method3()throws IOException {    
      method1();    
    }    
       
    //合法,声明抛出Exception,IOException是Exception的子类    
    void method4()throws Exception {    
      method1();    
    }    
       
    //合法,捕获IOException    
    void method5(){    
     try{    
        method1();    
     }catch(IOException e){…}    
    }    
       
    //编译错误,必须捕获或声明抛出Exception    
    void method6(){    
      try{    
        method1();    
      }catch(IOException e){throw new Exception();}    
    }    
       
    //合法,声明抛出Exception    
    void method7()throws Exception{    
     try{    
      method1();    
     }catch(IOException e){throw new Exception();}    
    }   

    判断一个方法可能会出现异常的依据如下:


         1)方法中有throw语句。例如,以上method7()方法的catch代码块有throw语句。


         2)调用了其他方法,其他方法用throws子句声明抛出某种异常。例如,method3()方法调用了method1()方法,method1()方法声明抛出IOException,因此,在method3()方法中可能会出现IOException。


    2. 使用throw抛出异常


       throw总是出现在函数体中,用来抛出一个Throwable类型的异常程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。
    我们知道,异常是异常类的实例对象,我们可以创建异常类的实例对象通过throw语句抛出。该语句的语法格式为:

        throw new exceptionname;


    例如抛出一个IOException类的异常对象:
        throw new IOException;


    要注意的是,throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象。下面的操作是错误的:
        throw new String("exception");


    这是因为String 不是Throwable 类的子类。

    如果抛出了检查异常,则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。

    如果所有方法都层层上抛获取的异常,最终JVM会进行处理,处理也很简单,就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException,则该方法的调用者可选择处理该异常。


    package Test;  
    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;  
        }  
    }  
    


    3)异常链


          1) 如果调用quotient(3,-1),将发生MyException异常,程序调转到catch (MyException e)代码块中执行;


          2) 如果调用quotient(5,0),将会因“除数为0”错误引发ArithmeticException异常,属于运行时异常类,由Java运行时系统自动抛出。quotient()方法没有捕捉ArithmeticException异常,Java运行时系统将沿方法调用栈查到main方法,将抛出的异常上传至quotient()方法的调用者:


             int result = quotient(a, b); // 调用方法quotient()


            由于该语句在try监控区域内,因此传回的“除数为0”的ArithmeticException异常由Java运行时系统抛出,并匹配catch子句:


    catch (ArithmeticException e) { // 处理ArithmeticException异常
        System.out.println("除数不能为0"); // 输出提示信息
    } 


            处理结果是输出“除数不能为0”。Java这种向上传递异常信息的处理机制,形成异常链

           Java方法抛出的可查异常将依据调用栈、沿着方法调用的层次结构一直传递到具备处理能力的调用方法,最高层次到main方法为止。如果异常传递到main方法,而main不具备处理能力,也没有通过throws声明抛出该异常,将可能出现编译错误。

          3)如还有其他异常发生,将使用catch (Exception e)捕捉异常。由于Exception是所有异常类的父类,如果将catch (Exception e)代码块放在其他两个代码块的前面,后面的代码块将永远得不到执行,就没有什么意义了,所以catch语句的顺序不可掉换。



    4)Throwable类中的常用方法


    注意:catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型,e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:

         getCause():返回抛出异常的原因。如果 cause 不存在或未知,则返回 null。

      getMeage():返回异常的消息信息。

      printStackTrace():对象的堆栈跟踪输出至错误输出流,作为字段 System.err 的值。


         有时为了简单会忽略掉catch语句后的代码,这样try-catch语句就成了一种摆设,一旦程序在运行过程中出现了异常,就会忽略处理异常,而错误发生的原因很难查找。


    5)Java中常见的异常类


    在Java中提供了一些异常用来描述经常发生的错误,对于这些异常,有的需要程序员进行捕获处理或声明抛出,有的是由Java虚拟机自动进行捕获处理。


    1. runtimeException子类:


        1、 java.lang.ArrayIndexOutOfBoundsException

        数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。


        2、java.lang.ArithmeticException

        算术条件异常。譬如:整数除零等。


        3、java.lang.NullPointerException

        空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等


        4、java.lang.ClassNotFoundException

        找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。


       5、java.lang.NegativeArraySizeException  数组长度为负异常


       6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常


       7、java.lang.SecurityException 安全性异常


       8、java.lang.IllegalArgumentException 非法参数异常


    2.IOException


    IOException:操作输入流和输出流时可能出现的异常。

    EOFException   文件已结束异常

    FileNotFoundException   文件未找到异常


    3. 其他


    ClassCastException    类型转换异常类

    ArrayStoreException  数组中包含不兼容的值抛出的异常

    SQLException   操作数据库异常类

    NoSuchFieldException   字段未找到异常

    NoSuchMethodException   方法未找到抛出的异常

    NumberFormatException    字符串转换为数字抛出的异常

    StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常

    IllegalAccessException  不允许访问某类异常

    InstantiationException  当应用程序试图使用Class类中的newInstance()方法创建一个类的实例,而指定的类对象无法被实例化时,抛出该异常


    展开全文
  • java异常拾遗

    千次阅读 2015-08-18 08:33:36
    当方法内部发生一项错误时,该方法会创建一个对象传递给运行时系统(runtime system),这个对象被称为异常对象,包含错误的类型、发生位置,程序状态等一系列信息。 当一个方法抛出异常时,运行时系统会沿着调用栈...
  • Java异常处理最佳实践

    千次阅读 2019-06-30 18:38:55
    Java 中处理异常并不是一个简单的事情。不仅仅初学者很难理解,即使一些有经验的开发者也需要花费很多时间来思考如何处理异常,包括需要处理哪些异常,怎样处理等等。这也是绝大多数开发团队都会制定一些规则来...
  • Java 异常处理

    千次阅读 2017-10-07 11:18:08
    总结异常的概念异常是程序中的一些错误,但不是所有的错误都是异常,并且错误有时候是可以避免的。比如说,你的代码少了一个分号,那么运行出来结果是提示是错误java.lang.Error;如果你用System.out
  • Java反射非法访问异常 java.lang.IllegalAccessException: Class com.hope.dao.BaseDao can not access a member of class com.hope.entity.User with modifiers “private” 错误信息: java.lang....
  • Java异常面试题

    万次阅读 多人点赞 2019-09-29 11:55:48
    文章目录1. Error 和 Exception 区别是什么?2. 运行时异常和一般异常区别是什么?3.NoClassDefFoundError 和 ClassNotFoundException 区别?4. JVM 是如何处理异常的?...7. Java常见异常有哪些 1. Error 和 Exce...
  • Java通过异常处理错误

    千次阅读 2016-10-31 23:11:09
    (2)异常情形(execptional condition):是指阻止当前方法或作用域继续执行的问题,在当前的环境下无法获取必要的信息来解决问题,必须从当前环境跳出,将问题提交给上一级环境,这是抛出异常发生的事情;...
  • Java自定义异常异常使用最佳实践

    千次阅读 2018-05-03 10:12:05
    转载自HOKING的专栏Java自定义异常异常使用最佳实践异常的分类1. 非运行时异常(Checked Exception) Java中凡是继承自Exception但不是继承自RuntimeException的类都是非运行时异常。2. 运行时异常(Runtime ...
  • java全局异常捕获

    千次阅读 2016-05-18 21:55:07
    Thread.setDefaultUncaughtException() 捕获所有程序为直接处理的,由虚拟机抛出的异常。Thread t = new Thread(); t.setUncaughtException() ...在上述两种方法中如果抛出了新的异常则会被JVM忽略
  • JAVA异常和自定义异常处理

    千次阅读 2019-01-30 23:04:03
    废话 作为一个码农想必对异常这一块滴已经是相当熟悉了就是我们常说的try/catch/finally吗,然后抛出捕获的异常信息...(1)运行时异常(checked exception):继承自java.lang. RuntimeException类 常见5种: Class...
  • 本文非常详尽地介绍了Java中的异常,几乎360度无死角。 从异常的概念,分类,使用方法,注意事项和设计等方面全面地介绍了Java异常。 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 喜欢的话...
  • Java异常类处理

    千次阅读 2020-08-15 15:42:03
    一、Java异常类的体系结构   1.程序出现异常时正常现象【就跟人会生病一样】   2.Java异常类Throwable【类】是顶级异常类   3.Throwable【类】有两个子类:     (1)Error【错误】     (2)...
  • Java异常处理机制

    千次阅读 2019-04-24 20:19:37
    作者:小符 撰写时间:2018.4.24 学会了异常处理可以帮助...Java异常处理机制为:抛出异常,捕捉异常,处理异常。 语法格式: try…catch 在使用try…catch捕获处理异常时需要注意: **·**不要过度使用异常,不能使...
  • java异常面试题

    千次阅读 2020-08-12 11:42:37
    Java异常架构与异常关键字 Java异常简介 Java异常架构 1. Throwable 2. Error(错误) 3. Exception(异常) 运行时异常 编译时异常 4. 受检异常与非受检异常 受检异常 ...
  • Java异常处理习题

    万次阅读 2017-10-05 17:45:16
    1、java中用来抛出异常的关键字是( ) A.try B.catch C.throw D.finally   2、关于异常,下列说法正确的是( ) A. 异常是一种对象 B.一旦程序运行,异常将被创建 C.为了保证程序运行速度,要尽量避免...
  • Java异常处理代码编写

    千次阅读 2019-08-19 10:12:38
    Java异常处理代码编写 java中的异常 在计算机程序运行的过程中,总是会出现各种各样的错误。 有一些错误是用户造成的,比如,希望用户输入一个int类型的年龄,但是用户的输入是abc: // 假设用户输入了abc: ...
  • Java 基础 - 异常机制详解

    万次阅读 2021-03-05 07:16:26
    Java异常Java提供的一种识别及响应错误的一致性机制,java异常机制可以使程序中异常处理代码和正常业务代码分离,保证程序代码更加优雅,提高程序健壮性。 异常的层次结构 异常指不期而至的各种状况,如:文件...
  • Java基础——Java异常处理机制

    千次阅读 2017-11-08 20:15:17
     由于运行时异常的不可查性,为了更合理、更容易地实现应用程序,Java规定,运行时异常将由Java运行时系统自动抛出,允许应用程序忽略运行时异常。  对于方法运行中可能出现的Error,当运行方法不欲捕捉时,...
  • 本文结合《Effective Java》第九章《异常》和自己的理解及实践,讲解了正确使用Java异常的优秀指导原则,文章发布于专栏Effective Java,欢迎读者订阅。
  • Java-异常Throwable,Exception,Error关系

    千次阅读 2019-05-24 10:15:26
    Java-异常Throwable,Exception,Error - 243573295 - 博客园 https://www.cnblogs.com/hwaggLee/p/4509038.html Java-异常Throwable,Exception,Error  异常指不期而至的各种状况,如:文件找不到、...
  • java异常解析以及自定义异常实例

    千次阅读 2017-10-14 11:16:09
    它封装了异常信息,java异常的根类为java.lang.Throwable,整个类有两个直接子类java.lang.Error和java.lang.Exception.Error是程序本身无法恢复的严重错误.Exception则表示可以被程序捕获处理的异常错误.JVM用方法...
  • 无论任何项目,都避免不了在运行期间出现的一些异常伴随着因业务逻辑的需要而给出相应的提示,使得系统变得更加友好,这类提示处理,我们统称为异常处理(exceptionahandling)。 在项目中异常处理所抛出的异常...
  • Java 异常设计最佳实践

    千次阅读 2016-08-05 10:49:31
    关于异常在讲Java异常实践之前,先理解一下什么是异常。到底什么才算是异常呢?其实异常可以看做在我们编程过程中遇到的一些意外情况,当出现这些意外情况时我们无法继续进程正常的逻辑处理,此时我们就可以抛出一个...
  • 【55】java异常机制剖析

    千次阅读 2016-06-04 16:49:42
    一、为什么要使用异常首先我们可以明确一点就是异常的处理机制可以确保我们程序的健壮性,提高系统可用率。虽然我们不是特别喜欢看到它,但是我们不能不承认它的地位,作用。有异常就说明程序存在问题,有助于我们...
  • Java异常处理练习题

    万次阅读 2014-07-28 22:26:01
    1、java中用来抛出异常的关键字是( ) A.try B.catch C.throw D.finally   2、关于异常,下列说法正确的是( ) A. 异常是一种对象 B.一旦程序运行,异常将被创建 C.为了保证程序运行速度,要尽量避免...
  • Java 异常分类及处理机制

    千次阅读 2016-04-01 14:42:29
    深入理解java异常处理机制 目录(?)[-]  1 引子 2JAVA异常 4处理异常机制 1 捕获异常trycatch 和 finally try-catch语句trycatch-finally语句try-catch-finally 规则异常处理语句的语法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 87,668
精华内容 35,067
关键字:

java获取异常并忽略

java 订阅