基本语法
Java异常类都实现了Throwable接口,分为两类异常,一类是编译时异常,另一类是RuntimeException,都继承了Exception类。
编译时的异常不需要用户自己处理,Java异常处理机制的应用对象都是运行时异常。
在程序中用throw关键字抛出异常,一旦抛出异常,要么通过try—catch处理异常,要么用throws关键字向上一级抛出异常。
interface A{
void f() throws NullPointerException;
}
class B implements A{
@Override
public void f() throws NullPointerException {
throw new NullPointerException();
}
public static void main(String[] args) {
B b = new B();
try{
b.f();
}
catch (NullPointerException e){
e.printStackTrace();
System.out.println("accepted");
}
finally {
System.out.println("Must handle");
}
}
}
java.lang.NullPointerException
at exceptionHandling.B.f(TestStackTrace.java:24)
at exceptionHandling.B.main(TestStackTrace.java:30)
accepted
Must handle
try语句块中可以抛出多个异常,编译器会自动匹配后面catch语句块中最合适的异常
finally关键字后的语句块无论抛不抛出异常都会执行,适合进行一些清理操作
其他操作
日志操作
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.logging.Logger;
class LoggingException extends Exception{
LoggingException(){}
LoggingException(String msg){
super(msg);
}
private static Logger logger = Logger.getLogger("LoggingException");
static void logException(Exception e){
StringWriter trace = new StringWriter();
e.printStackTrace(new PrintWriter(trace));
logger.severe(trace.toString());
}
}
public class TestLogger {
public static void main(String[] args) {
try{
throw new LoggingException("Lo");
}
catch (LoggingException e){
LoggingException.logException(e);
}
}
}
4月 11, 2020 10:47:23 下午 exceptionHandling.LoggingException logException
严重: exceptionHandling.LoggingException: Lo
at exceptionHandling.TestLogger.main(TestLogger.java:22)
打印栈路径
class WhoCalled{
static void f(){
try{
throw new Exception();
}
catch (Exception e){
for(StackTraceElement stackTraceElement:e.getStackTrace()) {
System.out.println(stackTraceElement.getMethodName());
}
}
}
}
public class TestStackTrace {
static void g(){
WhoCalled.f();
}
static void h(){
g();
}
public static void main(String[] args) {
g();
System.out.println();
h();
}
}
f
g
main
f
g
h
main
构造器抛出异常
构造时抛出的异常应该立即用catch单独处理,保证在后续操作中对象是已经创建完成的。
什么时候使用异常处理
- 在知道如何处理异常时,才处理
- 解决问题并且重新调用异常的方法
- 进行少许修补,然后绕过异常发生的地方继续进行
- 用别的数据计算解决异常
- 把当前环境下的事做完,向更高层抛出待解决的异常