在很多场景都有异常处理，python、C++、java中都存在，但是一直不理解异常处理的一些深层逻辑，在这里简要学习一下

Reference

什么是异常处理

  • 简单来说就是尽可能避免程序不正常运行的技术

我们可以自己写一个简单的swtich来判断接受的正确或错误的错误码，这个错误码通常是编程语言和API固定的

int code = processFile(“C:\\test.txt”);
if (code == 0) {
// ok:
} else {
// error:
switch (code) {
case 1:
// file not found:
case 2:
// no read permission:
default:
// unknown error:
}
}

但是上面这个判断有个问题，如果程序本身有严重错误，或者不可抗力的中断，处理起来就很困难

所有基本上每个语言都有自己的异常处理机制

try {
String s = processFile(“C:\\test.txt”);
// ok:
} catch (FileNotFoundException e) {
// file not found:
} catch (SecurityException e) {
// no read permission:
} catch (IOException e) {
// io error:
} catch (Exception e) {
// other error:
}

在廖雪峰的网站上可以看到一个异常体系图，Java的异常是class，很多异常存在继承关系，并且都继承自object

错误总体上分为:

  • Error表示严重的错误
  • Exception则是运行时的错误

举例分析

拿廖雪峰的例子分析一下

// try…catch
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Main {
public static void main(String[] args) {
byte[] bs = toGBK(“中文”);
System.out.println(Arrays.toString(bs));
} 

static byte\[\] toGBK(String s) {  
    try {  
        // 用指定编码转换String为byte\[\]:  
        return s.getBytes("GBK");  
    } catch (UnsupportedEncodingException e) {  
        // 如果系统不支持GBK编码，会捕获到UnsupportedEncodingException:  
        System.out.println(e); // 打印异常信息  
        return s.getBytes(); // 尝试使用用默认编码  
    }  
}

}

但是如果我们不捕获的话，会在toGBK()中提示你做异常处理，可以试一试

import java.sql.*;
import java.util.Arrays;

public class Main {
public static void main(String[] args) {
byte[] bs = toGBK(“中文”);
System.out.println(Arrays.toString(bs));
} 

static byte\[\] toGBK(String s) {  
    return s.getBytes("GBK");  //没有捕获异常  
}

}

输出为：java: 未报告的异常错误java.io.UnsupportedEncodingException; 必须对其进行捕获或声明以便抛出

但是这种机制是如何建立的？

编译器是如何知道需要写一个异常的？

这是因为String.getBytes(String)方法定义是：

public byte[] getBytes(String charsetName) throws UnsupportedEncodingException {
…
}

**在方法定义的时候，使用throws Xxx表示该方法可能抛出的异常类型。**调用方在调用的时候，必须强制捕获这些异常，否则编译器会报错。也就是说，自己的写的方法如果包含了throws，如果你在调用时没有做异常处理，那么同样也会有编译器的提醒

那么修改为如下的代码

// try…catch
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Main {
public static void main(String[] args) {
byte[] bs = toGBK(“中文”);
System.out.println(Arrays.toString(bs));
} 

static byte\[\] toGBK(String s) throws UnsupportedEncodingException {  
    return s.getBytes("GBK");  
}

}

此时编译也是不通过的，异常处理的提醒就是在main函数中，因为toGBK定义了throws 异常UnsupportedEncodingException，所有调用者都应该用try…catch…捕获这个异常

正确的修改如下：

// try…catch
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Main {
public static void main(String[] args) {
try {
byte[] bs = toGBK(“中文”);
System.out.println(Arrays.toString(bs));
} catch (UnsupportedEncodingException e) {
System.out.println(e);
}
} 

static byte\[\] toGBK(String s) throws UnsupportedEncodingException {  
    // 用指定编码转换String为byte\[\]:  
    return s.getBytes("GBK");  
}

}

下面这个结论很重要：

只要是方法声明的Checked Exception，不在调用层捕获，也必须在更高的调用层捕获。所有未捕获的异常，最终也必须在main()方法中捕获，不会出现漏写try的情况。这是由编译器保证的。main()方法也是最后捕获Exception的机会。

日常技巧

偷懒可以这样写

public class Main {
public static void main(String[] args) throws Exception { // 在main函数抛出
byte[] bs = toGBK(“中文”);
System.out.println(Arrays.toString(bs));
} 

static byte\[\] toGBK(String s) throws UnsupportedEncodingException {  
    // 用指定编码转换String为byte\[\]:  
    return s.getBytes("GBK");  
}

}

代价就是一旦发生异常，程序会立刻退出。

另一种就是，不知道出现异常做什么的时候，用异常栈来记录

static byte[] toGBK(String s) {
try {
return s.getBytes(“GBK”);
} catch (UnsupportedEncodingException e) {
// 先记下来再说:
e.printStackTrace();
}
return null;

所有异常都可以调用printStackTrace()方法打印异常栈，这是一个简单有用的快速打印异常的方法。