优化Java代码：高效利用异常处理技巧

概述

在使用计算机语言进行项目开发的过程中，即使程序员把代码写的尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码就能避免的，比如：客户输入数据的格式问题，输入的文件是否存在，网络是否始终通畅等。

那么在程序执行过程中，出现的非正常情况，如果不处理最终会导致JVM的非正常停止，这就是异常。

异常指的并不是语法错误和逻辑错误，语法错了编译不会通过，不会产生字节码文件，根本不能运行。而代码逻辑错误，只是没有得到想要的结果。

Java中把不同的异常用不同的类表示，一旦发生某种异常，就创建该异常类型的对象并且抛出(throw)，然后程序员可以catch到这个异常对象并处理，如果无法catch到异常对象，那么这个异常对象将会导致程序的终止。

所以在编写程序时，就应该充分考虑到各种可能发生的异常和错误，极力的预防和避免，实在无法避免的，也要编写相应的代码进行异常的检测、以及处理，从而保证代码的健壮性。

Java异常体系

Error和Exception

Java程序在执行过程中所发生的异常事件可分为两类：Error和Exception，分别对应着java.lang.Error和java.lang.Exception两个类。

Error是Java虚拟机无法解决的严重问题，如JVM系统内部错误、资源耗尽等严重情况，一般不编写针对性的代码进行处理。

Exception是因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理，使程序继续运行，但只要发生必须处理，否则程序也会终止，例如：

• 空指针访问
• 试图读取不存在的文件
• 网络连接中断
• 数组角标越界

无论是Error还是Exception，还有很多子类，异常的类型非常丰富，当代码运行出现异常时，特别是不熟悉的异常时，可以在API中通过异常的类名去查询。

提示： 平时说的异常就是指Exception。

Throwable

java.lang.Throwable类是Error和Exception的父类。只有当对象是此类(或其子类之一)的实例时，才能通过Java虚拟机或Java的throw语句抛出，同样的只有此类或其子类之一才可以是catch子句中的参数类型。

Throwable中的常用方法：

• public void printStackTrace()：打印异常的详细信息，包含了异常的类型、原因和出现的位置，在开发和调试阶段都得使用printStackTrace。
• public String getMessage()：获取发生异常的原因，提示给用户的时候就提示错误的原因。

常见的错误和异常

对于程序出现的异常，一般有两种，一是遇到错误就终止程序的运行，另一种是由程序员在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理。

最理想的捕获异常是在编译期间，但有的错误只有在运行时才会发生，比如数组下标越界等。因此根据代码的执行阶段，编译器是否会警示当前代码可能发生异常，并督促程序员提前编写处理它的代码为依据，可以将异常分为编译时异常和运行时异常。

编译时异常

编译时异常(checked异常、受检异常)：在代码编译阶段，编译器就能明确警示当前代码可能发生但不一定发生的异常，并明确督促提前编写处理代码，如果没有编写相应的异常处理代码，则编译器就直接判定编译失败，从而导致程序无法执行，通常这类异常的发生不是由编写的代码引起的，或不是靠加简单判断可以避免的。

示例：

import org.junit.Test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class TestCheckedException {
    @Test
    public void test01() {
        Thread.sleep(1000); //休眠1秒，InterruptedException
    }
    @Test
    public void test02(){
        Class c = Class.forName("java.lang.String"); //ClassNotFoundException
    }
    @Test
    public void test03() {
        Connection conn = DriverManager.getConnection("xxx");  //SQLException
    }
    @Test
    public void test04()  {
        FileInputStream fis = new FileInputStream("xxx.txt"); //FileNotFoundException
    }
    @Test
    public void test5() {
        File file = new File("xxx.txt");
		FileInputStream fis = new FileInputStream(file); //FileNotFoundException
		int b = fis.read(); //IOException
		while(b != -1){
			System.out.print((char)b);
			b = fis.read(); //IOException
		}
		fis.close(); //IOException
    }
}

运行时异常

运行时异常(runtime异常、unchecked异常、非受检异常)：在代码编译阶段，编译器完全不做任何的检查，无论该异常是否会发生，编译器都不给出任何提示。只有等代码运行起来并确定发生了异常才能被发现，通常这类异常是由程序员的代码编写不当引起的，只要稍加判断或细心检查就可以避免。

示例：

import org.junit.Test;
import java.util.Scanner;

public class TestRuntimeException {
    @Test
    public void test01(){
        //NullPointerException
        int[][] arr = new int[3][];
        System.out.println(arr[0].length);
    }
    @Test
    public void test02(){
        //ClassCastException
        Object obj = 15;
        String str = (String) obj;
    }
    @Test
    public void test03(){
        //ArrayIndexOutOfBoundsException
        int[] arr = new int[5];
        for (int i = 1; i <= 5; i++) {
            System.out.println(arr[i]);
        }
    }
    @Test
    public void test04(){
        //InputMismatchException
        Scanner input = new Scanner(System.in);
        System.out.print("请输入一个整数："); //输入非整数
        int num = input.nextInt();
        input.close();
    }
    @Test
    public void test05(){
        int a = 1;
        int b = 0;
        //ArithmeticException
        System.out.println(a/b);
    }
}

Error

最常见的就是VirtualMachineError，有两个经典的子类：StackOverflowError、OutOfMemoryError。

示例：

import org.junit.Test;

public class TestError {
    //StackOverflowError
    @Test
    public void test01(){
        recursion();
    }
    public void recursion(){ //递归方法
        recursion(); 
    }
    //OutOfMemoryError
    @Test
    public void test02(){
        int[] arr = new int[Integer.MAX_VALUE]; //方式一
    }
    @Test
    public void test03(){
        StringBuilder s = new StringBuilder(); //方式二
        while(true){
            s.append("xxx");
        }
    }
}

异常的处理

在编写程序时，经常要在可能出现错误的地方加上检测的代码，如进行除法运算时，需要检测分母是否为0等，这样一来会出现过多的if-else分支，导致程序的代码加长、臃肿，可读性差，程序员需要花很大的精力去堵漏洞，因此采用异常处理机制。

Java采用的异常处理机制是将异常处理的程序代码集中到一起，与正常的代码分开，使得程序简洁优雅并易于维护。

Java异常处理的方式有两种，一种是try-catch-finally，另一种是throws+异常类型。

捕获异常

Java提供了异常处理的抓抛模型，之前提到Java程序的执行过程中如果出现异常，会生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出异常。

如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理，如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法，这个过程将一直继续下去，直到异常被处理，这个过程称为捕获异常。

如果一个异常回到main方法，并且main方法不处理，则程序终止。

捕获异常的语法如下：

try{
	...... //可能产生异常的代码
}
catch( 异常类型1 e ){
	...... //当产生ExceptionName1类型异常时的处理
}
catch( 异常类型2 e ){
	...... //当产生ExceptionName2类型异常时的处理
}  
[finally{
	...... //无论是否发生异常，都无条件执行的代码
}]

当某段代码可能发生异常时，不管此异常是编译时异常还是运行时异常，都可以使用try块括起来，并在try块下面编写catch分支捕获对应的异常对象。

• 如果在程序运行时，try中代码没有发生异常，则catch中代码不执行
• 如果在程序运行时，try中代码发生了异常，则根据异常的类型从上到下选择第一个匹配的catch分支执行，此时try中发生异常的语句下面的代码将不执行，整个try-catch之后的代码可以继续执行
• 如果在程序运行时，try中代码发生了异常，但所有的catch分支都无法匹配这个异常，那么JVM将会终止当前方法的执行，并把异常对象抛给调用者，如果调用者也不处理，那么程序就挂了

注意： 当有多个catch分支时，且多个异常类型有父子类关系，必须保证小的子异常类型在上，大的父异常类型在下。

示例：

import java.util.InputMismatchException;
import java.util.Scanner;

public class TestTryCatch {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        try {
            System.out.print("请输入第一个整数：");
            int a = input.nextInt();
            System.out.print("请输入第二个整数：");
            int b = input.nextInt();
            int result = a/b;
            System.out.println(a + "/" + b +"=" + result);
        } catch (InputMismatchException e) {
            System.out.println("数字格式不正确，请输入两个整数");
        }catch (ArithmeticException e){
            System.out.println("第二个整数不能为0");
        } finally {
            System.out.println("程序结束，释放资源");
            input.close();
        }
    }
}

catch捕获异常的信息，与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法，为此Throwable类中定义了一些查看方法，比如有：

• public String getMessage()：获取异常的描述信息，返回字符串
• public void printStackTrace()：打印异常的跟踪栈信息并输出到控制台，包含异常的类型、原因和出现的位置，在开发和调试阶段都得使用printStackTrace

示例：

@Test
public void test1(){
	FileInputStream fis = null;
	try{
		File file = new File("xxx.txt");
		fis = new FileInputStream(file); //FileNotFoundException
		int b = fis.read(); //IOException
		while(b != -1){
			System.out.print((char)b);
			b = fis.read(); //IOException
		}
	}catch(IOException e){
		e.printStackTrace();
	}finally{
		try {
			if(fis != null)
				fis.close(); //IOException
		} catch (IOException e) {
			e.printStackTrace();
		}	
	}
}

如果多个catch分支的异常处理代码一致，在JDK1.7之后还支持以下写法：

try{
     可能发生异常的代码
}catch(异常类型1 | 异常类型2  e){
     处理异常的代码1
}catch(异常类型3  e){
     处理异常的代码2
}
....

最后，这些异常都是运行时异常类或它的子类，这些异常类的特点是即使没有使用try-catch，Java也能捕获并且编译通过。如果抛出的异常是IOException等类型的非运行时异常，则必须捕获，否则编译错误，所以必须处理编译时异常，将异常进行捕获转化为运行时异常。

声明抛出异常类型

如果一个方法可能生成某种异常，但并不能确定如何处理这种异常，则此方法应显示的声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

throws声明异常格式如下：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2...{   }	

在throws后面可以写多个异常类型，用逗号隔开。

示例：

public void readFile(String file)  throws FileNotFoundException {
	...
	//读文件的操作可能产生FileNotFoundException类型的异常
	FileInputStream fis = new FileInputStream(file);
	...
}

throws编译时异常：

如果在编写方法体代码时，某代码可能发生某个编译时异常，不处理编译不通过，但在当前方法体中可能不适合处理或无法给出合理的处理方式，就可以通过throws在方法签名中声明该方法可能会发生异常，需要调用者处理。

示例：

public class TestThrowsCheckedException {
    public static void main(String[] args) {
        System.out.println("xxxxxx");
        try {
            afterClass(); //换到这里处理异常
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("XXXXXX");
        }
        System.out.println("......");
    }
    public static void afterClass() throws InterruptedException {
        for(int i=10; i>=1; i--){
            Thread.sleep(1000); //本来应该在这里处理异常
            System.out.println("xxxxxx" + i);
        }
    }
}

throws运行时异常：

throws后面也可以写运行时异常类型，只是运行时异常类型写或不写对于编译器和程序执行来说都没有任何区别，如果写了，唯一的区别就是调用者调用该方法后使用try-catch结构时，idea可以获得更多的信息，需要添加哪种catch分支。

示例：

import java.util.InputMismatchException;
import java.util.Scanner;

public class TestThrowsRuntimeException {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        try {
            System.out.print("请输入第一个整数：");
            int a = input.nextInt();
            System.out.print("请输入第二个整数：");
            int b = input.nextInt();
            int result = divide(a,b);
            System.out.println(a + "/" + b +"=" + result);
        } catch (ArithmeticException | InputMismatchException e) {
            e.printStackTrace();
        } finally {
            input.close();
        }
    }
    public static int divide(int a, int b)throws ArithmeticException{
        return a/b;
    }
}

方法重写对于throws的要求：

方法重写时，对于方法签名是有严格要求的，比如：

• 方法名必须相同
• 形参列表必须相同
• 返回值类型：基本数据类型和void必须相同；引用数据类型要<=
• 权限修饰符：>=，而且要求父类被重写方法在子类中是可见的
• 不能是static、final修饰的方法

此外，对于throws异常列表要求：

• 如果父类被重写方法的方法签名后没有throws编译时异常类型，那么重写方法时，方法签名后面也不能出现throws编译时异常类型
• 如果父类被重写方法的方法签名后面有throws 编译时异常类型，那么重写方法时throws的编译时异常类型必须<=被重写方法throws的编译时异常类型，或者不throws编译时异常
• 方法重写对于throws 运行时异常类型没有要求

示例：

import java.io.IOException;

class Father{
    public void method()throws Exception{
        System.out.println("Father.method");
    }
}
class Son extends Father{
    @Override
    public void method() throws IOException,ClassCastException {
        System.out.println("Son.method");
    }
}

手动抛出异常对象：throw

Java中异常对象的生成有两种方式：

• 由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，针对当前代码就会在后台自动创建一个对应异常类的实例对象并抛出
• 由开发人员手动创建：new 异常类型([实参列表])，如果创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样，但一旦throw抛出，就会对程序运行产生影响了

语法格式

使用格式如下：

throw new 异常类名(参数);

throw语句抛出的异常对象和JVM自动创建和抛出的异常对象一样：

• 如果是编译时异常类型的对象，同样需要使用throws或try-catch处理，否则编译不通过
• 如果是运行时异常类型的对象，编译器不提示
• 可以抛出的异常必须是Throwable或其子类的实例

//编译时会产生语法错误
throw new String("want to throw");

注意事项

无论是编译时异常类型的对象还是运行时异常类型的对象，如果没有被try-catch合理的处理，都会导致程序的崩溃。

throw语句会导致程序执行流程被改变，throw语句是明确抛出一个异常对象，因此它下面的代码将不会执行。

如果当前方法没有try-catch处理这个异常对象，throw语句就会代替return语句提前终止当前方法的执行，并返回一个异常对象给调用者。

示例：

public class TestThrow {
    public static void main(String[] args) {
        try {
            System.out.println(max(4,2,31,1));
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            System.out.println(max(4));
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            System.out.println(max());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static int max(int... nums){
        if(nums == null || nums.length==0){
            throw new IllegalArgumentException("没有传入任何整数，无法获取最大值");
        }
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if(nums[i] > max){
                max = nums[i];
            }
        }
        return max;
    }
}

自定义异常

为什么需要自定义异常类

Java中不同的异常类分别表示着某一种具体的异常情况，那么在开发中总是有些异常情况是核心类库中没有定义好的，此时就需要根据自己的业务异常情况来定义异常类。

如何自定义异常类

1. 要继承一个异常类型。
   • 自定义一个编译时异常类型：自定义类继承java.lang.Exception
   • 自定义一个运行时异常类型：自定义类继承java.lang.RuntimeException
2. 建议提供至少两个构造器，一个是无参构造器一个是(String message)构造器。
3. 自定义异常需要提供serialVersionUID。

注意：

1. 自定义的异常只能通过throw抛出。
2. 自定义异常最重要的是异常类的名字和message属性，当异常出现时可以根据名字判断异常类型。
3. 自定义异常对象只能手动抛出，抛出后由try-catch处理，也可以甩锅throws给调用者处理。

示例：

//自定义异常类
class MyException extends Exception {
    static final long serialVersionUID = 23423423435L;
    private int idnumber;
    public MyException(String message, int id) {
        super(message);
        this.idnumber = id;
    }
    public int getId() {
        return idnumber;
    }
}
//测试
public class MyExpTest {
    public void regist(int num) throws MyException {
        if (num < 0)
            throw new MyException("人数为负值，不合理", 3);
        else
            System.out.println("登记人数" + num);
    }
    public void manager() {
        try {
            regist(100);
        } catch (MyException e) {
            System.out.print("登记失败，出错种类" + e.getId());
        }
        System.out.print("本次登记操作结束");
    }
    public static void main(String args[]) {
        MyExpTest t = new MyExpTest();
        t.manager();
    }
}

小结

异常处理的5个关键字：

今天的内容就到这里，喜欢的话点个关注吧，下篇见！