java对于可查异常必须捕捉,异常CocoaChina_一站式开发者成长社区

1 ** 所有异常的父类是throwable**

2 throws表示抛出异常的一种可能性&＃xff0c;不一定会&＃xff0c;throw一定抛出了某一种异常

3 捕获到的异常不仅可以在当前的方法里面进行处理还可以将异常抛给调用它的上一级

1 throws是用来声明一个成员方法可能抛出的各种异常情况&＃xff0c;第二&＃xff1a;final用于可以声明属性和方法&＃xff0c;分别表示属性的不可变及方法的不可覆盖。不是方法的不可继承第三&＃xff1a;throw是用来明确地抛出一个异常情况。错误&＃xff0c;throw不仅仅可以抛出异常&＃xff0c;还可以抛出Error以及Throwable.

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

2.Error(错误): 是程序无法处理的错误。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时&＃xff0c;一般不需要程序处理。

3.检查异常(编译器要求必须处置的异常) &＃xff1a; 除了Error&＃xff0c;RuntimeException及其子类以外&＃xff0c;其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它&＃xff0c;也就是说&＃xff0c;当程序中可能出现这类异常&＃xff0c;要么用try-catch语句捕获它&＃xff0c;要么用throws子句声明抛出它&＃xff0c;否则编译不会通过。

4.非检查异常(编译器不要求处置的异常): 包括运行时异常(RuntimeException与其子类)和错误(Error)。**

3 A.除数为0 等ArithmeticException&＃xff0c;是RuntimException的子类。而运行时异常将由运行时系统自动抛出&＃xff0c;不需要使用throw语句。Java编译器 允许忽略运行时异常&＃xff0c;一个方法可以既不捕捉&＃xff0c;也不声明抛出运行时异常。

4 java中的异常通常分为编译时异常和运行异常。编译时异常需要我们手动的进行捕捉处理&＃xff0c;也就是我们用try…catch块进行捕捉处理。对于运行时异常只有在编译器在编译运行时才会出现&＃xff0c;这些不需要我们手动进行处理。对于A、 B、 D来说都是运行时异常

5 处理异常常用的两种方式&＃xff1a;

1、try…catch(捕获处理机制)&＃xff1b;

2、throws(冒泡处理机制).

注意细节&＃xff1a;使用try…catch块捕获时可以没有catch块,但当没用catch块的时候必须得有finally块.故选A)

6 捕获到的异常不仅可以在当前方法中处理&＃xff0c;还可以将异常抛给调用它的上一级方法来处理

7 java中的异常通常分为编译时异常和运行异常。编译时异常需要我们手动的进行捕捉处理&＃xff0c;也就是我们用try…catch块进行捕捉处理。对于运行时异常只有在编译器在编译运行时才会出现&＃xff0c;这些不需要我们手动进行处理

8 throw用于抛出异常。

throws关键字可以在方法上声明该方法要抛出的异常&＃xff0c;然后在方法内部通过throw抛出异常对象。

try是用于检测被包住的语句块是否出现异常&＃xff0c;如果有异常&＃xff0c;则抛出异常&＃xff0c;并执行catch语句。

cacth用于捕获从try中抛出的异常并作出处理。

finally语句块是不管有没有出现异常都要执行的内容。

9 运行时异常故名思议就是程序在运行的时候出现异常&＃xff0c;隐含的一个前提就是程序在编译时是检测不到异常的存在&＃xff0c;作者本人也并不知道是否自己的代码中含有运行时异常&＃xff0c;所以根本也不可能提前使用try{}catch{}捕获&＃xff0e;

10 假如try中有异常抛出&＃xff0c;则会去执行catch块&＃xff0c;再去执行finally块&＃xff1b;假如没有catch 块&＃xff0c;可以直接执行finally 块&＃xff0c;方法就以抛出异常的方式结束&＃xff0c;而finally 后的内容也不会被执行&＃xff0c;所以catch 和 finally 不能同时省略。

11 首先所有异常都是Exception的子类。

比如用Exception

因为所有异常都是Exception的子类,如果你把Exception放在前边捕获,后边的catch将永远不会执行—简单记忆&＃xff1a;老将(牛X的)都是最后出马

( 若 catch 中的参数类型有父类子类关系&＃xff0c;此时应该将父类放在后面&＃xff0c;子类放在前面 )

12 checked exception&＃xff1a;指的是编译时异常&＃xff0c;该类异常需要本函数必须处理的&＃xff0c;用try和catch处理&＃xff0c;或者用throws抛出异常&＃xff0c;然后交给调用者去处理异常。

runtime exception&＃xff1a;指的是运行时异常&＃xff0c;该类异常不必须本函数必须处理&＃xff0c;当然也可以处理。

Thread.sleep()抛出的InterruptException属于checked exception&＃xff1b;IllegalArgumentException属于Runtime exception;

40 异常分为运行时异常&＃xff0c;非运行时异常和error&＃xff0c;其中error是系统异常&＃xff0c;只能重启系统解决。非运行时异常需要我们自己补获&＃xff0c;而运行异常是程序运行时由虚拟机帮助我们补获&＃xff0c;运行时异常包括数组的溢出&＃xff0c;内存的溢出空指针&＃xff0c;分母为0等&＃xff01;

41 Exception(异常)

是程序本身可以处理的异常。主要包含RuntimeException等运行时异常和IOException&＃xff0c;SQLException等非运行时异常。

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

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

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

43 异常&＃xff1a;编译–需要处理&＃xff0c;运行不需要的&＃xff0c;可能的try catch,error致命的错误&＃xff01;

44 finally一定会在return之前执行&＃xff0c;但是如果finally使用了return或者throw语句&＃xff0c;将会使trycatch中的return或者throw失效

45 **结论&＃xff1a;

1、不管有木有出现异常&＃xff0c;finally块中代码都会执行&＃xff1b;

2、当try和catch中有return时&＃xff0c;finally仍然会执行&＃xff1b;

3、finally是在return后面的表达式运算后执行的(此时并没有返回运算后的值&＃xff0c;而是先把要返回的值保存起来&＃xff0c;管finally中的代码怎么样&＃xff0c;返回的值都不会改变&＃xff0c;任然是之前保存的值)&＃xff0c;所以函数返回值是在finally执行前确定的&＃xff1b;

4、finally中最好不要包含return&＃xff0c;否则程序会提前退出&＃xff0c;返回值不是try或catch中保存的返回值。

46 1、int i &＃61; 100/ 0; 会出现异常&＃xff0c;会抛出异常&＃xff0c;System.out.print(i)不会执行&＃xff0c;

2、catch捕捉异常&＃xff0c;继续执行System.out.print(1);

3、当执行 thrownewRuntimeException(); 又会抛出异常&＃xff0c;这时&＃xff0c;除了会执行finally中的代码&＃xff0c;其他地方的代码都不会执行

48 所有的异常直直接继承exception&＃xff0c;Throwable是总基类–注意审题&＃xff01;&＃xff01;&＃xff01;

1. 在Finally中清理资源或者使用Try-With-Resource语句

2.使用Finally

相比于try&＃xff0c;无论是在成功执行try里的代码后&＃xff0c;或是在catch中处理了一个异常后&＃xff0c;Finally里的内容是一定会被执行的。因此&＃xff0c;可以确保清理所有已打开的资源。

3 给出准确的异常处理信息

你抛出的异常越具体越好。一定要记住&＃xff0c;一个不太了解你代码的同事&＃xff0c;也许几个月后&＃xff0c;需要调用你的方法&＃xff0c;并且处理这个异常。

因此&＃xff0c;请确保提供尽可能多的信息&＃xff0c;这会使你的API更容易理解。因此&＃xff0c;你方法的调用者将能够更好地处理异常&＃xff0c;或者通过额外的检查来避免它。

所以&＃xff0c;要尽量能更好地描述你的异常处理信息&＃xff0c;比如用NumberFormatException代替IllegalArgumentException&＃xff0c;避免抛出一个不具体的异常。

5. 最先捕获特定的异常–老将最后出马

大多数IDE都可以帮助你做到这点&＃xff0c;当你试图捕获不确定的异常时&＃xff0c;它会报告一个不可到达的代码块。

问题是只有第一个匹配到异常的catch语句才会被执行&＃xff0c;所以&＃xff0c;如果你最先发现IllegalArgumentException&＃xff0c;你将永远不会到达catch里处理更具体的NumberFormatException&＃xff0c;因为它是IllegalArgumentException的一个子类。

所以要首先捕获特定的异常类&＃xff0c;并在末尾添加一些处理不是很具体异常的catch语句。

你可以在下面的代码片段中看到这样一个try-catch语句的示例。第一个catch处理所有NumberFormatExceptions异常&＃xff0c;第二个catch 处理NumberFormatException异常以外的illegalargumentexception异常。

public void catchMostSpecificExceptionFirst() {

try {

doSomething("A message");

} catch (NumberFormatException e) {

log.error(e);

} catch (IllegalArgumentException e) {

log.error(e)

}

}

6. 不要在catch中使用Throwable

Throwable是exceptions 和 errors的父类。当然&＃xff0c;你可以在catch子句中使用它&＃xff0c;但其实你不应该这样做。

如果你在catch子句中使用Throwable&＃xff0c;它将不仅捕获所有的异常&＃xff0c;还会捕获所有错误。JVM会抛出错误&＃xff0c;这是应用程序不打算处理的严重问题。典型的例子是OutOfMemoryError或StackOverflowError。这两种情况都是由应用程序控制之外的情况引起的&＃xff0c;无法处理。

所以&＃xff0c;最好不要在catch中使用Throwable&＃xff0c;除非你完全确定自己处于一个特殊的情况下&＃xff0c;并且你需要处理一个错误。

public void doNotCatchThrowable() {

try {

// do something

} catch (Throwable t) {

// don&＃39;t do this!

}

}

7. 不要忽略Exceptions

这通常是由一个被忽略的异常引起的。开发人员可能非常确信它不会被抛出&＃xff0c;并添加一个无法处理或无法记录它的catch语句。当你发现它的时候&＃xff0c;你很可能就会明白一句著名的话“This will never happen”。

public void doNotIgnoreExceptions() {

try {

// do something

} catch (NumberFormatException e) {

// this will never happen

}

}

是的&＃xff0c;你可能在分析一个不可能发生的问题。

所以&＃xff0c;请千万不要忽略一个例外。你不会知道代码在将来会发生什么变化。有些人可能会删除阻止异常事件的验证&＃xff0c;而没有意识到这造成了问题。或者抛出异常的代码被更改&＃xff0c;现在抛出了同一个类的多个异常&＃xff0c;而调用的代码并不能阻止所有这些异常。

你至少应该写一个日志信息&＃xff0c;告诉每个人&＃xff0c;需要检查一下这个问题。

public void logAnException() {

try {

// do something

} catch (NumberFormatException e) {

log.error("This should never happen: " &＃43; e);

}

}

8. 不要记录和抛出一个异常

这可能是最常被忽略的。你可以在许多代码片段或者库文件里发现&＃xff0c;有异常会被捕获、记录和重新抛出。

try {

new Long("xyz");

} catch (NumberFormatException e) {

log.error(e);

throw e;

}

当它发生时记录一个异常&＃xff0c;然后重新抛出它&＃xff0c;以便调用者能够适当地处理它&＃xff0c;这可能会很直观。但是它会为同一个异常写多个错误消息。

9. 包装异常

有时最好捕获一个标准异常并将其封装到一个定制的异常中。此类异常的典型例子是应用程序或框架特定的业务异常。这允许你添加额外的信息&＃xff0c;并且也可以为异常类实现一个特殊的处理。

当你这样做时&＃xff0c;确保引用原始的异常处理。Exception类提供了一些特定的构造函数方法&＃xff0c;这些方法可以接受Throwable作为参数。否则&＃xff0c;你将丢失原始异常的堆栈跟踪和消息&＃xff0c;这将使你很难分析导致异常的事件

public void wrapException(String input) throws MyBusinessException {

try {

// do something

} catch (NumberFormatException e) {

throw new MyBusinessException("A message that describes the error.", e);

}

}

Java异常处理面试题

1 异常处理完成以后&＃xff0c;Exception对象会发生什么变化&＃xff1f;

Exception对象会在下一个垃圾回收过程中被回收掉。

2 下面关于java.lang.Exception类的说法正确的是()

A. 继承自 Throwable

B. Serialable

CD 不记得&＃xff0c;反正不正确

答案&＃xff1a;A

解析&＃xff1a;Java 异常的基类为 java.lang.Throwable&＃xff0c;java.lang.Error 和 java.lang.Exception 继承 Throwable&＃xff0c;RuntimeException 和其它的 Exception 等继承 Exception&＃xff0c;具体的 RuntimeException 继承 RuntimeException。

3 扩展&＃xff1a;错误和异常的区别(Error vs Exception)

java.lang.Error: Throwable 的子类&＃xff0c;**用于标记严重错误。**合理的应用程序不应该去 try/catch 这种错误。绝大多数的错误都是非正常的&＃xff0c;就根本不该出现的。

java.lang.Exception: Throwable 的子类&＃xff0c;用于指示一种合理的程序想去 catch 的条件。即它仅仅是一种程序运行条件&＃xff0c;而非严重错误&＃xff0c;并且鼓励用户程序去 catch 它。

getCustomerInfo() 方法如下&＃xff0c;try 中可以捕获三种类型的异常&＃xff0c;如果在该方法运行中产生了一个 IOException&＃xff0c;将会输出什么结果?

public void getCustomerInfo() {

try {

// do something that may cause an Exception

} catch (java.io.FileNotFoundException ex) {

System.out.print("FileNotFoundException!");

} catch (java.io.IOException ex) {

System.out.print("IOException!");

} catch (java.lang.Exception ex) {

System.out.print("Exception!");

}

}

A. IOException!

B. IOException!Exception!

C. FileNotFoundException!IOException!

D. FileNotFoundException!IOException!Exception!

答案&＃xff1a;A

解析&＃xff1a;考察多个 catch 语句块的执行顺序。当用多个 catch 语句时&＃xff0c;catch 语句块在次序上有先后之分。从最前面的 catch 语句块依次先后进行异常类型匹配&＃xff0c;**这样如果父异常在子异常类之前&＃xff0c;那么首先匹配的将是父异常类&＃xff0c;子异常类将不会获得匹配的机会&＃xff0c;**也即子异常类型所在的 catch 语句块将是不可到达的语句。所以&＃xff0c;一般将父类异常类即 Exception 老大放在 catch 语句块的最后一个。

4 try{} 里有一个 return 语句&＃xff0c;那么紧跟在这个 try 后的 finally{} 里的 code 会不会被执行&＃xff0c;什么时候被执行&＃xff0c;在 return 前还是后?

答&＃xff1a;会执行&＃xff0c;在方法返回调用者前执行。Java允许在finally中改变返回值的做法是不好的&＃xff0c;因为如果存在finally代码块&＃xff0c;**try 中的return语句不会立马返回调用者&＃xff0c;而是记录下返回值待 finally 代码块执行完毕之后再向调用者返回其值&＃xff0c;然后如果在 finally 中修改了返回值&＃xff0c;这会对程序造成很大的困扰&＃xff0c;**C# 中就从语法上规定不能做这样的事。

5 Java 语言如何进行异常处理&＃xff0c;关键字&＃xff1a;throws、throw、try、catch、finally 分别如何使用&＃xff1f;

答&＃xff1a;Java 通过面向对象的方法进行异常处理&＃xff0c;把各种不同的异常进行分类&＃xff0c;并提供了良好的接口。在 Java 中&＃xff0c;每个异常都是一个对象&＃xff0c;它是 Throwable 类或其子类的实例。当一个方法出现异常后便抛出一个异常对象&＃xff0c;该对象中包含有异常信息&＃xff0c;调用这个对象的方法可以捕获到这个异常并进行处理。

Java 的异常处理是通过5个关键词来实现的&＃xff1a;try、catch、throw、throws 和 finally。

一般情况下是用try来执行一段程序&＃xff0c;如果出现异常&＃xff0c;**系统会抛出(throw)一个异常&＃xff0c;**这时候你可以通过它的类型来捕捉(catch)它&＃xff0c;或最后(finally)由缺省处理器来处理&＃xff1b;try用来指定一块预防所有“异常”的程序&＃xff1b;catch子句紧跟在try块后面&＃xff0c;用来指定你想要捕捉的“异常”的类型&＃xff1b;**throw语句用来明确地抛出一个“异常”&＃xff1b;throws用来标明一个成员函数可能抛出的各种“异常”&＃xff1b;**finally为确保一段代码不管发生什么“异常”都被执行一段代码&＃xff1b;可以在一个成员函数调用的外面写一个try语句&＃xff0c;在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句&＃xff0c;“异常”的框架就放到栈上面&＃xff0c;直到所有的try语句都完成。如果下一级的try语句没有对某种“异常”进行处理&＃xff0c;栈就会展开&＃xff0c;直到遇到有处理这种“异常”的 try 语句。

7 请写出 5 种常见到的runtime exception。

答&＃xff1a;

NullPointerException&＃xff1a;当操作一个空引用时会出现此错误。

NumberFormatException&＃xff1a;数据格式转换出现问题时出现此异常。

ClassCastException&＃xff1a;强制类型转换类型不匹配时出现此异常。

ArrayIndexOutOfBoundsException&＃xff1a;数组下标越界&＃xff0c;当使用一个不存在的数组下标时出现此异常。

ArithmeticException&＃xff1a;数学运行错误时出现此异常

8 error 和 exception 有什么区别?

答&＃xff1a;

error 表示系统级的错误和程序不必处理的异常&＃xff0c;是恢复不是不可能但很困难的情况下的一种严重问题**&＃xff1b;比如内存溢出&＃xff0c;不**可能指望程序能处理这样的情况&＃xff1b; exception 表示需要捕捉或者需要程序进行处理的异常&＃xff0c;是一种设计或实现问题&＃xff1b;也就是说&＃xff0c;它表示如果程序运行正常&＃xff0c;从不会发生的情况。