涉及到异常类相关的文章:
(1)异常类不能是泛型的 http://www.cnblogs.com/extjs4/p/8888085.html
(2)Finally block may not complete normally的问题,参考文章:https://www.cnblogs.com/extjs4/p/9375400.html
(3)JLS https://docs.oracle.com/javase/specs/jls/se7/html/jls-11.html#jls-11.2
(4)关于动态代理的异常 http://www.importnew.com/28664.html
try{ }catch(Exception e){ }
上面的例子不会报错,虽然try块中不会抛出异常,所以catch中Exception或者Exception的父类时不要求try块中一定要抛出相应异常。
Throwable为顶层父类,派生出Error类和Exception类,如下图:
错误:Error类以及他的子类的实例,代表了JVM本身的错误。错误不能被程序员通过代码处理,Error很少出现。因此,程序员应该关注Exception为父类的分支下的各种异常类。
关于断言的java.lang.AssertionError也是无法处理的,如果出现错误,程序将终止。开启断言可在Eclipse中的VM arguments中传入参数:-ea 进行开启
异常:Exception以及他的子类,代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用,是异常处理的核心。而且如果这些异常没有被处理,会导致线程退出。异常又分为非检查异常(unckecked exception)与检查异常(checked exception)。
由上图可以看出,继承
例1:
class SubThread extends Thread {
@Override
public void run() throws ArithmeticException{
int i = 0;
int x = i / i; // 抛出java.lang.ArithmeticException
System.out.println("SubThread end...");
}
}
运行时异常如果不处理最终还是会导致线程终止。
例2:
class SubThread extends Thread {
@Override
public void run() throws ArithmeticException{
int i = 0;
try {
int x = i / i;
} catch (Exception e) {
throw e;
}
System.out.println("SubThread end...");
}
}
抛出异常时没有具体进行处理,同样会导致线程终止。如果注释掉throw e语句后,则线程就可正常结束打印出SubThread end...
11.2.1. Exception Analysis of Expressions
A class instance creation expression (§15.9) can throw an exception class E iff either:
-
The expression is a qualified class instance creation expression and the qualifying expression can throw E; or
-
E is determined to be an exception class of the
throws
clause of the constructor that is invoked (§15.12.2.6); or -
The class instance creation expression includes a ClassBody, and some instance initializer block or instance variable initializer expression in the ClassBody can throw E.
A method invocation expression (§15.12) can throw an exception class E iff either:
-
The method to be invoked is of the form Primary.Identifierand the Primary expression can throw E; or
-
E is determined to be an exception class of the
throws
clause of the method that is invoked (§15.12.2.6).
For every other kind of expression, the expression can throw an exception class E iff one of its immediate subexpressions can throw E.
eg1:
class FirstException extends Exception { }
class AA{
public AA() throws FirstException{}
}
// 方法上必须有FirstException,否则下面抛出FirstException都将报错
public void dd() throws FirstException {
AA a = new AA(){}; // // throw FirstException
Object b = new Object(){
// instance variable initializer
AA a = new AA(); // throw FirstException
// instance initializer block
{
AA a = new AA(); // // throw FirstException
}
};
}
A throw
statement (§14.18) whose thrown expression has static type E and is not a final or effectively final exception parameter can throw E or any exception class that the thrown expression can throw.
For example, the statement throw new java.io.FileNotFoundException();
can throw java.io.FileNotFoundException
only. Formally, it is not the case that it "can throw" a subclass or superclass of java.io.FileNotFoundException
.
A throw
statement whose thrown expression is a final or effectively final exception parameter of a catch
clause C can throw an exception class E iff:
-
E is an exception class that the
try
block of thetry
statement which declares C can throw; and -
E is assignment compatible with any of C's catchable exception classes; and
-
E is not assignment compatible with any of the catchable exception classes of the
catch
clauses declared to the left of C in the sametry
statement.
A try
statement (§14.20) can throw an exception class E iff either:
-
The
try
block can throw E, or an expression used to initialize a resource (in atry
-with-resources statement) can throw E, or the automatic invocation of theclose()
method of a resource (in atry
-with-resources statement) can throw E, and E is not assignment compatible with any catchable exception class of anycatch
clause of thetry
statement, and either nofinally
block is present or thefinally
block can complete normally; or -
Some
catch
block of thetry
statement can throw E and either nofinally
block is present or thefinally
block can complete normally; or
An explicit constructor invocation statement (§8.8.7.1) can throw an exception class E iff either:
-
Some expression of the constructor invocation's parameter list can throw E; or
-
E is determined to be an exception class of the
throws
clause of the constructor that is invoked (§15.12.2.6).
Any other statement S can throw an exception class E iff an expression or statement immediately contained in S can throw E.
关于异常的一些注意点:
(1)If a catch
block handles more than one exception type, then the catch
parameter is implicitly final
.
(2)Rethrowing Exceptions with More Inclusive Type Checking(更具包容性的类型检查)
static class FirstException extends Exception { }
static class SecondException extends Exception { }
// Java7之前对异常的处理
public void rethrowExceptionPriorSE7(String exceptionName)
throws Exception {
try {
if (exceptionName.equals("First")) {
throw new FirstException();
} else {
throw new SecondException();
}
} catch (Exception e) {
throw e;
}
}
// Java7新增对异常的处理语法
public void rethrowExceptionSE7(String exceptionName)
throws FirstException, SecondException {
try {
if (exceptionName.equals("First")) {
throw new FirstException();
} else {
throw new SecondException();
}
} catch (Exception e) {
throw e;
}
}
In detail, in Java SE 7 and later, when you declare one or more exception types in a catch
clause, and rethrow the exception handled by this catch
block, the compiler verifies that the type of the rethrown exception meets the following conditions:
- The
try
block is able to throw it. - There are no other preceding
catch
blocks that can handle it. - It is a subtype or supertype of one of the
catch
clause's exception parameters.
如上的三条对Java7及后面的版本来说都需要进行检查,如下:
static class FirstException extends Exception { }
static class SecondException extends FirstException { }
// Java7新增对异常的处理语法
public void rethrowExceptionSE7(String exceptionName)
throws FirstException, SecondException {
try {
throw new FirstException();
} catch (SecondException e) {
throw e;
}
}
在try块中抛出父类异常,在catch中捕获子类异常,这是允许的。
参考:
(1)http://www.importnew.com/26613.html
(2)https://docs.oracle.com/javase/specs/jls/se7/html/jls-11.html
(3)https://docs.oracle.com/javase/8/docs/technotes/guides/language/catch-multiple.html