精华内容
参与话题
问答
  • JAVA异常的几种处理方式

    千次阅读 2019-01-16 22:48:00
    这一篇主要说一下如何处理异常。 首先处理异常主要有两种方式:一种try catch,一种是throws。 1. try catch: try{} 中放入可能发生异常的代码。catch{}中放入对捕获到异常之后的处理。其中catch中e....

    上一篇简单介绍异常的几种类型。这一篇主要说一下如何处理异常。

    首先处理异常主要有两种方式:一种try catch,一种是throws

    1. try catch:

    try{} 中放入可能发生异常的代码。catch{}中放入对捕获到异常之后的处理。其中catch中e.printStackTrace()作用就是,在控制台打印程序出错的位置及原因。try{} 中放入可能发生异常的代码。catch{}中放入对捕获到异常之后的处理。其中catch中e.printStackTrace()作用就是,在控制台打印程序出错的位置及原因。

    只有try块中代码发生异常才会走到 catch块。

    有的异常捕获会加上finally,无论try块中异常有无捕获finally块中最后都会执行,除非try块代码中有 system.exit(0)(system.exit(0)的作用是退出虚拟机)。
    https://www.cnblogs.com/hyzxx/p/5151911.html。 这篇文章细致的分析了try catch finally 中有return的情况,想了解的可以去看一下。

    2. throw throws:

    • throw是语句抛出异常,出现于函数内部,用来抛出一个具体异常实例,throw被执行后面的语句不起作用,直接转入异常处理阶段,例子如下:
      throw

    • throws是函数方法抛出异常,一般写在方法的头部,用来抛出一些异常,本身不进行解决,抛给方法的调用者进行解决(try catch),例子如下:
      throws

    参考文章:
    https://jingyan.baidu.com/album/f25ef25447919b482c1b829c.html?picindex=1
    http://sa.sogou.com/sgsearch/sgs_tc_news.php?tencentdocid=20180904A130L300&req=yPDas6hC39q1mByPubwiiT7jlQ5uz_nsz2AzF-Z4C5Y=&user_type=1

    展开全文
  • java(3)-深入理解java异常处理机制

    万次阅读 多人点赞 2011-01-20 18:44:00
    1. 引子 try…catch…finally恐怕是大家再熟悉不过的语句了,而且感觉用起来也是很简单,逻辑上似乎也是很容易理解。不过,我亲自体验的“教训”告诉我,这个东西可不是想象中的那么简单、听话。...

     

     1. 前言:引子


           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最好是其他语句来处理相关逻辑。

     

     2.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异常,一般情况下不自定义检查异常

      

     3.处理异常机制


            在 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语句块的执行
     

    4.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.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.4 Throwable类中的常用方法

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

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

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

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

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

     

    4.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异常的捕获及处理

    万次阅读 多人点赞 2019-03-16 15:28:13
    一、Java异常简介 什么是异常? 程序运行时,发生的不被期望的事件,它阻止了程序按照程序员的预期正常执行,这就是异常。异常发生时,是任程序自生自灭,立刻退出终止。在Java中即,Java在编译或运行或者运行过程...

    一、Java异常简介

    什么是异常?
    程序运行时,发生的不被期望的事件,它阻止了程序按照程序员的预期正常执行,这就是异常。异常发生时,是任程序自生自灭,立刻退出终止。在Java中即,Java在编译或运行或者运行过程中出现的错误

    Java提供了更加优秀的解决办法:异常处理机制。

    异常处理机制能让程序在异常发生时,按照代码的预先设定的异常处理逻辑,针对性地处理异常,让程序尽最大可能恢复正常并继续执行,且保持代码的清晰。
    Java中的异常可以是函数中的语句执行时引发的,也可以是程序员通过throw 语句手动抛出的,只要在Java程序中产生了异常,就会用一个对应类型的异常对象来封装异常,JRE就会试图寻找异常处理程序来处理异常。

    Java异常机制用到的几个关键字:try、catch、finally、throw、throws。

    •  try        -- 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内,当try语句块内发生异常时,异常就被抛出。
    • catch   -- 用于捕获异常。catch用来捕获try语句块中发生的异常。
    • finally  -- finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块,执行完成之后,才会回来执行try或者catch块中的return或者throw语句,如果finally中使用了return或者throw等终止方法的语句,则就不会跳回执行,直接停止。
    • throw   -- 用于抛出异常。
    • throws -- 用在方法签名中,用于声明该方法可能抛出的异常。主方法上也可以使用throws抛出。如果在主方法上使用了throws抛出,就表示在主方法里面可以不用强制性进行异常处理,如果出现了异常,就交给JVM进行默认处理,则此时会导致程序中断执行。

    产生异常的原因:

    • 用户输入了非法数据。
    • 要打开的文件不存在。
    • 网络通信时连接中断,或者JVM内存溢出。

    这些异常有的是因为用户错误引起,有的是程序错误引起的,还有其它一些是因为物理错误引起的。

    三种类型的异常:

    • 检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。
    • 运行时异常: 运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。
    • 错误: 错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。

    二、Java异常的分类

    异常的根接口Throwable,其下有2个子接口,Error和Exception。

    •  Error:指的是JVM错误,这时的程序并没有执行,无法处理;
    • Exception:指的是程序运行中产生的异常,用户可以使用处理格式处理。

    Java 内置异常类

    Java 语言定义了一些异常类在 java.lang 标准包中。

    标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的,所以大部分从运行时异常类继承而来的异常都可以直接使用。

    Java 根据各个类库也定义了一些其他的异常,下面的表中列出了 Java 的非检查性异常

    异常 描述
    ArithmeticException 当出现异常的运算条件时,抛出此异常。例如,一个整数"除以零"时,抛出此类的一个实例。
    ArrayIndexOutOfBoundsException 用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。
    ArrayStoreException 试图将错误类型的对象存储到一个对象数组时抛出的异常。
    ClassCastException 当试图将对象强制转换为不是实例的子类时,抛出该异常。
    IllegalArgumentException 抛出的异常表明向方法传递了一个不合法或不正确的参数。
    IllegalMonitorStateException 抛出的异常表明某一线程已经试图等待对象的监视器,或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
    IllegalStateException 在非法或不适当的时间调用方法时产生的信号。换句话说,即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。
    IllegalThreadStateException 线程没有处于请求操作所要求的适当状态时抛出的异常。
    IndexOutOfBoundsException 指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。
    NegativeArraySizeException 如果应用程序试图创建大小为负的数组,则抛出该异常。
    NullPointerException 当应用程序试图在需要对象的地方使用 null 时,抛出该异常
    NumberFormatException 当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。
    SecurityException 由安全管理器抛出的异常,指示存在安全侵犯。
    StringIndexOutOfBoundsException 此异常由 String 方法抛出,指示索引或者为负,或者超出字符串的大小。
    UnsupportedOperationException 当不支持请求的操作时,抛出该异常。

    下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类

    异常 描述
    ClassNotFoundException 应用程序试图加载类时,找不到相应的类,抛出该异常。
    CloneNotSupportedException 当调用 Object 类中的 clone 方法克隆对象,但该对象的类无法实现 Cloneable 接口时,抛出该异常。
    IllegalAccessException 拒绝访问一个类的时候,抛出该异常。
    InstantiationException 当试图使用 Class 类中的 newInstance 方法创建一个类的实例,而指定的类对象因为是一个接口或是一个抽象类而无法实例化时,抛出该异常。
    InterruptedException 一个线程被另一个线程中断,抛出该异常。
    NoSuchFieldException 请求的变量不存在
    NoSuchMethodException 请求的方法不存在

    异常方法

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

    序号 方法及说明
    1 public String getMessage()
    返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。
    2 public Throwable getCause()
    返回一个Throwable 对象代表异常原因。
    3 public String toString()
    使用getMessage()的结果返回类的串级名字。
    4 public void printStackTrace()
    打印toString()结果和栈层次到System.err,即错误输出流。
    5 public StackTraceElement [] getStackTrace()
    返回一个包含堆栈层次的数组。下标为0的元素代表栈顶,最后一个元素代表方法调用堆栈的栈底。
    6 public Throwable fillInStackTrace()
    用当前的调用栈层次填充Throwable 对象栈层次,添加到栈层次任何先前信息中。

    三、异常的使用及执行流程

    1、异常的处理方案

    try...catch、try...catch...finally、try...finally
        try{
            可能会发生的异常
        }catch(异常类型 异常名(变量)){
            针对异常进行处理的代码
        }catch(异常类型 异常名(变量)){
            针对异常进行处理的代码
        }...
        [finally{
            释放资源代码;
        }]

    注意:

    • catch 不能独立于 try 存在。
    • catch里面不能没有内容
    • 在 try/catch 后面添加 finally 块并非强制性要求的。
    • try 代码后不能既没 catch 块也没 finally 块。
    • try里面越少越好。
    • try, catch, finally 块之间不能添加任何代码。
    • finally里面的代码最终一定会执行(除了JVM退出)
    • 如果程序可能存在多个异常,需要多个catch进行捕获。
    • 异常如果是同级关系,catch谁前谁后没有关系
      如果异常之间存在上下级关系,上级需要放在后面

    2、异常的执行流程

    Error与Exception的区别:

    Error(错误)是系统中的错误,程序员是不能改变的和处理的,是在程序编译时出现的错误,只能通过修改程序才能修正。一般是指与虚拟机相关的问题,如系统崩溃,虚拟机错误,内存空间不足,方法调用栈溢等。对于这类错误的导致的应用程序中断,仅靠程序本身无法恢复和和预防,遇到这样的错误,建议让程序终止。

    Exception(异常)表示程序可以处理的异常,可以捕获且可能恢复。遇到这类异常,应该尽可能处理异常,使程序恢复运行,而不应该随意终止异常。

    在catch捕获异常时,为什么不考虑使用Throwable类型,而只是使用Exception来进行接收?

    Throwable表示的范围要比Exception大。实际上程序使用Throwable来进行处理,没有任何语法问题,但是却会存在逻辑问题。因为此时出现的(或者说用户能够处理的)只有Exception类型,而如果使用Throwable接收,还会表示可以处理Error的错误,而用户是处理不了Error错误的,所以在开发中用户可以处理的异常都要求以Exception类为主。

    异常是一起处理好还是分开处理好?

    根据实际的开发要求是否严格来决定。在实际的项目开发项目工作中,所有的异常是统一使用Exception处理还是分开处理,完全根据开发者的项目开发标准来决定。如果项目开发环境严谨,基本上要求针对每一种异常分别进行处理,并且要详细记录下异常产生的时间以及产生的位置,这样可以方便程序维护人员进行代码的维护。再次注意:处理多个异常时,捕获范围小的异常要放在捕获范围大的异常之前处理。

    throw和throws的区别?

    throw和throws都是在异常处理中使用的关键字,区别如下:

    • throw:指的是在方法中人为抛出一个异常对象(这个异常对象可能是自己实例化或者抛出已存在的);
    • throws:在方法的声明上使用,表示此方法在调用时必须处理异常。

    检查型异常(Checked Exception)与非检查型异常(Unchecked Exception)区别?

    • 所有的检查性异常都继承自java.lang.Exception;所有的非检查性异常都继承自java.lang.RuntimeEx ception。
    • 检查性异常和非检查性异常最主要的区别在于其处理异常的方式:检查性异常必须使用try catch或者throws等关键字进行处理,否则编译器会报错;非检查性异常一般是程序代码写的不够严谨而导致的问题,可以通过修改代码来规避。
    • 常见的运行时异常:空指针异常(NullPointerException)、除零异常(ArithmeticException)、数组越界异常(ArrayIndexOutOfBoundsException)等;
    • 常见的检查性异常:输入输出异常(IOException)、文件不存在异常(FileNotFoundException)、SQL语句异常(SQLException)等。

    assert关键字(了解)

    在Java中,assert关键字是从JAVA SE 1.4 引入的,为了避免和老版本的Java代码中使用了assert关键字导致错误,Java在执行的时候默认是不启动断言检查的(这个时候,所有的断言语句都 将忽略!),如果要开启断言检查,则需要用开关-enableassertions或-ea来开启。

    assert关键字语法很简单,有两种用法:

    1. assert <boolean表达式>
      如果<boolean表达式>为true,则程序继续执行。
      如果为false,则程序抛出AssertionError,并终止执行。
    2. assert <boolean表达式> : <错误信息表达式>
      如果<boolean表达式>为true,则程序继续执行。
      如果为false,则程序抛出java.lang.AssertionError,并输入<错误信息表达式>。

    例如:

    public class Test {
    	public static void main(String[] args) {
    		int a = 10;
    		int b = 2;
    		assert a == 10:"a不等于10";
    		System.out.println("a="+a);
    	}
    }

     执行结果为:

    public class Test {
    	public static void main(String[] args) {
    		int a = 10;
    		int b = 2;
    		assert a == 20:"a不等于20";
    		System.out.println("a="+a);
    	}
    }

    执行结果为:

    四、自定义异常

    在 Java 中你可以自定义异常。如果要自定义异常类,则扩展Exception类即可,因此这样的自定义异常都属于检查异常(checked exception)。如果要自定义非检查异常,则扩展自RuntimeException。

    按照国际惯例,自定义的异常应该总是包含如下的构造函数:

    • 一个无参构造函数
    • 一个带有String参数的构造函数,并传递给父类的构造函数。
    • 一个带有String参数和Throwable参数,并都传递给父类构造函数
    • 一个带有Throwable 参数的构造函数,并传递给父类的构造函数。

    下面是IOException类的完整源代码,可以借鉴。

    package java.io;
    
    public class IOException extends Exception {
        static final long serialVersionUID = 7818375828146090155L;
    
        public IOException() {
    	super();
        }
    
        public IOException(String message) {
    	super(message);
        }
    
        public IOException(String message, Throwable cause) {
            super(message, cause);
        }
    
        public IOException(Throwable cause) {
            super(cause);
        }
    }
    

    finally块和return

    • 首先一个不容易理解的事实:在 try块中即便有return,break,continue等改变执行流的语句,finally也会执行。
    • finally中的return 会覆盖 try 或者catch中的返回值。
    • finally中的return或异常会抑制(消灭)前面try或者catch块中的异常。
    展开全文
  • Java异常类型及处理

    万次阅读 多人点赞 2018-09-21 10:54:18
    Java异常,大家都很熟悉。但是对于具体怎么分类的,JVM对其怎么处理的,代码中怎么处理的,应该怎么使用,底层怎么实现的等等,可能就会有些不是那么清晰。本文基于此详细捋一下异常类型,实现以及使用时应怎么注意...

    前言:

    Java异常,大家都很熟悉。但是对于具体怎么分类的,JVM对其怎么处理的,代码中怎么处理的,应该怎么使用,底层怎么实现的等等,可能就会有些不是那么清晰。本文基于此详细捋一下异常类型,实现以及使用时应怎么注意。

    一、异常实现及分类

    1.先看下异常类的结构图

    上图可以简单展示一下异常类实现结构图,当然上图不是所有的异常,用户自己也可以自定义异常实现。上图已经足够帮我们解释和理解异常实现了:

    1.所有的异常都是从Throwable继承而来的,是所有异常的共同祖先。

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

    3.Exception,是另外一个非常重要的异常子类。它规定的异常是程序本身可以处理的异常。异常和错误的区别是,异常是可以被处理的,而错误是没法处理的。 

    4.Checked Exception

    可检查的异常,这是编码时非常常用的,所有checked exception都是需要在代码中处理的。它们的发生是可以预测的,正常的一种情况,可以合理的处理。比如IOException,或者一些自定义的异常。除了RuntimeException及其子类以外,都是checked exception。

    5.Unchecked Exception

    RuntimeException及其子类都是unchecked exception。比如NPE空指针异常,除数为0的算数异常ArithmeticException等等,这种异常是运行时发生,无法预先捕捉处理的。Error也是unchecked exception,也是无法预先处理的。

    二、异常的处理 

    代码中的异常处理其实是对可检查异常的处理。

    1. 通过try...catch语句块来处理:

    e.g.

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

    Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时,try 后面的 catch 块就会被检查。

    如果发生的异常包含在 catch 块中,异常会被传递到该 catch 块,这和传递一个参数到方法是一样。

    2. 另外,也可以在具体位置不处理,直接抛出,通过throws/throw到上层再进行处理,具体的,如果一个方法没有捕获到一个检查性异常,那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。也可以使用 throw 关键字抛出一个异常,无论它是新实例化的还是刚捕获到的。

    下面方法的声明抛出一个 RemoteException 异常:

    import java.io.*;
    public class className
    {
      public void deposit(double amount) throws RemoteException
      {
        // Method implementation
        throw new RemoteException();
      }
      //Remainder of class definition
    }

    3. finally关键字

    finally 关键字用来创建在 try 代码块后面执行的代码块。

    无论是否发生异常,finally 代码块中的代码总会被执行。

    在 finally 代码块中,可以运行清理类型等收尾善后性质的语句。

    finally 代码块出现在 catch 代码块最后,语法如下:

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

     

    小结:

    本文对于异常的结构关系,分类,处理系统的简单整理了一下,能帮助我在理论上串起来,希望也能帮助有需要的朋友。

    展开全文
  • Java异常处理

    千次阅读 2018-07-25 20:25:50
    处理反馈、业务异常、代码错误 在开发业务系统中,我们目前绝大多数采用MVC模式,但是往往有人把service跟controller紧紧的耦合在一起, 甚至直接使用Threadlocal来隐式传值,并且复杂的逻辑几乎只能使用service中存储...
  • JAVA异常处理最佳实战心得

    千次阅读 2018-09-28 16:42:12
    尤其是在各种服务相关的代码中,可能正常业务逻辑的代码量很少,大部分都是各种try catch处理各种异常的代码,因为实际中异常情况很多,为了保证服务的健壮与稳定性,要尽可能考虑与处理掉各种异常情况。所以在java...
  • 1、异常:就是程序运行时出现不正常情况异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。对于问题的划分(两种):...
  • Java异常处理和异常抛出

    千次阅读 2019-02-21 13:11:44
    生活中的异常是指那些有异于常态,和正常情况...这时异常处理机制就很重要了,它会以适当的方法让程序继续执行或者退出,并且能够保存用户的当前操作或者进行数据回滚,最后再把占用的资源释放掉。 一.Java异常体系...
  • Java异常的几种处理方式

    万次阅读 2018-08-28 21:30:03
    Java异常处理机制包含4,5中处理方式,今天我们来谈谈这几种方式的实现: 1)try...catch...分为单catch与多catch处理方式,其本质执行方法基本相同: 2)try...catch...finally: 3)自动关闭资源的try语句:...
  • java异常处理

    千次阅读 2019-05-22 20:24:23
    一.finally的意思是:只要你进入try,不管你是怎样离开的,一定要在离开前执行finally的代码。...(2)try中抛出的异常在try后面的catch中捕捉到并处理完了。这种情况下本来是继续执行下面的代码,现...
  • Java异常处理机制

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

    千次阅读 2016-08-24 14:35:19
    Java异常处理主要依赖于try,catch,finally,throws,throw这五个关键字。下面分别介绍它们:
  • java异常处理机制简述

    千次阅读 2014-08-12 10:31:04
    Java异常处理机制是这样的 try{}是监控的代码,catch{}是处理异常,finally{}是无论是否发生异常,无论异常是否处理都会执行的代码。而finally后面的代码是否执行的关键就是是否有catch语句。catch就是处理异常,...
  • Java异常处理机制简述

    2019-09-06 21:13:35
    异常 异常是导致程序中断执行的一种指令流;...1.程序异常处理机制: 1.try{…}catch(…){…} public class Demo{ public static void main(String[] args){ System.out.println("********程序开始执行*****...
  • 简记c、c++、java异常处理机制的区别

    千次阅读 2013-05-24 10:40:54
    一、C异常处理:用于多层返回的setjmp/longjmp机制 C中的异常处理是通过setjmp.h头文件中定义的宏setjmp和宏longjmp实现的。 类似于退栈,setjmp/longjmp机制的使用方法: 在希望进行错误处理的位置用setjmp...
  • 理解Java异常处理机制——Java异常处理的一个综合实例 佟强 2009年12月8日声明抛出异常如果程序员不想在当前方法内处理异常,可以使用throws语句声明将异常抛出到调用方法中。调用方法也可以将异常再抛给其他调用...
  • 深入理解java异常处理机制

    千次阅读 2016-07-12 09:12:29
    try…catch…finally恐怕是大家再熟悉不过的语句了,而且感觉用起来也是很简单,逻辑上似乎也是很容易理解。不过,我亲自体验的“教训” 告诉我,这个东西可不是想象中的那么简单、听话。不信?...
  • java异常处理机制简单原理和应用

    千次阅读 2015-03-11 21:08:30
    异常java程序运行时(非编译)所发生的非正常情况或错误。 java异常进行了分类,不同类型的异常使用了不同的java类,所有异常的根类为java.lang.Throwable.Throwable派生了2个子类:Error和Exception. Error...
  • Java异常处理机制的简单原理和应用

    千次阅读 2017-07-10 11:17:27
    异常是指Java程序运行时所发生的非正常情况或者错误,就像人们正常生活发生...可以 用一个对象来表示,Java采用面向对象的方式来处理异常,把程序中发生的每个异常都封装到一个对象来表 示, 该对象里面包含有异常信息
  • Java异常处理机制(经典)

    千次阅读 2016-03-21 00:07:38
    目前主流的编程语言如,C++、C#、Java都提供了异常处理机制。增加异常处理机制使程序有更好的兼容性、健壮性。  异常处理是程序设计中一个非常重要的方面,也是程序设计的一大难点,从C开始,也许已用if...else......

空空如也

1 2 3 4 5 ... 20
收藏数 681,446
精华内容 272,578
关键字:

java异常处理

java 订阅