1. 为什么需要异常处理

运行下面的代码，看看有什么问题。

public static void main(String[] args) {
	int num1 = 10;
	int num2 = 0;
	int res = num1 / num2;
	System.out.println("程序继续运行....");
}
1
2
3
4
5
6

运行结果：

  当执行到 num1 / num2 时，因为 num2 = 0, 所以程序会抛出异常 ArithmeticException。当抛出异常后，程序就退出，崩溃了，下面的代码不再执行。这样的程序存在问题，因为可能会因为一个不算致命的问题导致整个系统崩溃。
  为此，Java 设计者提供了 “异常处理机制” ：如果一段代码可能出现问题，可以用 try-catch 异常处理机制来解决，从而保证程序的健壮性。这样，即使代码运行时出现问题，也可以继续执行。
  方法：在 idea 中选中代码块，按下快捷键 ctrl + alt + t ，选择 try-catch。

public class Exception01 {
	public static void main(String[] args) {
		int num1 = 10;
		int num2 = 0;
		try {
			int res = num1 / num2;
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("程序继续运行....");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

运行结果：

  可以看到，捕获异常后，程序仍可以继续执行。

  如果不希望看到默认抛出的异常，还可以修改catch中的语句，使捕获到异常后再做其他操作，如：给res赋一个默认值、去读取一个输入的值等。下面输出异常出现的原因：

public class Exception01 {
	public static void main(String[] args) {
		int num1 = 10;
		int num2 = 0;
		try {
			int res = num1 / num2;
		} catch (Exception e) {
			System.out.println("出现异常的原因=" + e.getMessage());//输出异常信息
		}
		System.out.println("程序继续运行....");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

运行结果：

2. 异常的基本介绍

在 Java 中，将程序执行时的不正常情况称为 “异常”，可分为两类：
（1）Error(错误）：Java虚拟机无法解决的严重问题。如：JVM 系统内部错误、资源耗尽等严重情况。比如：StackOverflowError（栈溢出）和OOM（out of memory）。
（2）Exception：其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。如：空指针访问，试图读取不存在的文件，网络连接中断等。Exception 又分为两大类：运行时异常和编译时异常。

运行时异常：一般是指逻辑错误，编译器检查不出来。java.lang.RuntimeException 类及它的子类都是运行时异常。运行时异常是应该避免的，若全处理可能会对程序的可读性和运行效率产生影响。
编译时异常：是编译器要求必须处置的异常。

2.1 五大运行时异常

• NullPsinterException 空指针异常
  

• ArithmeticException 数学运算异常
  
  （如前面除以0的例子）

• ArraylndexOutOfBoundsException 数组下标越界异常
  
  

• ClassCastException 类型转换异常
  
  

• NumberFormatException 数字格式不正确异常：当试图将字符串转换成一种数值类型，但实际上该字符串不能转换为适当格式时，抛出该异常 =>可以确保输入数字。
  
  

2.2 编译时异常

编译时异常：在编译时就必须处理的异常，否则代码不能通过编译。

常见的编译时异常：

因为还没有讲到 SQL、文件编程等，这里先举一个
（FileNotFoundException）案例来说明，其它异常使用方式类似。

3. 异常处理机制

异常处理：当异常发生时，对异常处理的方式。

异常处理的方式：

• try-catch-finally：程序员在代码中捕获发生的异常，自行处理。
  

• throws：将发生的异常抛出，交给调用者（方法）来处理，最顶级的处理者就是 JVM。
  如下图：假设 main 方法调用了 f1 方法，f1 方法又调用了 f2 方法。若 f2 中出现异常，f2 可以用 try-catch-finally 的方式自行处理，也可以将异常 throws 给它的调用者 f1 方法；若 f2 方法将异常 throws 给 f1，f1 同样有上述两种处理方式，main 方法也一样。若异常被一路 throws 到 JVM，JVM就会亲自处理异常：输出异常信息、退出程序。
  

【注】

• 在处理异常时，try-catch-finally 和 throws 二选一即可。
• 如果程序员没有显式处理异常，默认用 throws 方式。如前面的例子：
  
  异常被抛给 main 方法的上一级 JVM，JVM 输出异常信息、退出程序。分析到这里，就验证了程序的输出为什么是下图：
  

4. try-catch 异常

  Java 提供 try 和 catch 块来处理异常。try 块用于包含可能出错的代码。catch 块用于处理 try 块中发生的异常。可以根据需要在程序中有多个 try-catch 块。
基本语法:

try{
	//可疑代码
	//将异常生成对应的异常对象，传递给catch块
}catch(异常对象）{
	//对异常的处理
}
//如果没有finally，语法是可以通过的
1
2
3
4
5
6
7

注意事项：
（1）如果异常发生了，则 try 块中剩余的代码不会执行，直接进入到 catch 块。catch 块后面的其他代码仍会执行。

输出结果：

（2）如果异常没有发生，则顺序执行 try 的代码块，不会进入到catch。

输出结果：

（3）如果希望不管是否发生异常，都执行某段代码（比如关闭连接，释放资源等），就要使用finally{}。

（4）可以有多个 catch 语句，捕获不同的异常（进行不同的业务处理），要求子类异常在前，父类异常在后。如果发生异常，只会匹配一个catch。（注意：异常后面的代码不会执行，直接进入到 catch 块）
下图中，NullPointerException 和 ArithmeticException 异常的捕获应该在 Exception 捕获的前面，否则报错。因为 Exception 可以捕获前两者，若把 Exception 写在最前面，其他两个异常的捕获就没有意义了。

（5）可以进行 try-finally 配合使用，这种用法相当于没有捕获异常。因此若出现异常，程序会在执行完 finally 后直接崩掉 / 退出。应用场景：执行一段代码，不管是否发生异常，都必须执行某个业务逻辑。

try 中有异常时：

上面代码没有用 catch 捕获异常，等价于把该异常 throws 给 JVM 处理。JVM 输出异常信息、退出程序。所以输出结果为：

try 中无异常时：

输出结果：

try-catch 练习

【例1】看下面代码，输出什么？

public class Exception01{
    public static int method() {
        try {
            String[] names = new String[3];
            if (names[1].equals("tom")) {//NullPointerException
                System.out.println(names[1]);
            } else {
                names[3] = "hspedu";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            return 2;
        } catch (NullPointerException e) {//在这捕获异常
            //但是后面的finally无论如何必须执行，所以此处不能返回
            return 3;
        } finally {//必须执行
            return 4;//返回4
        }
    }
     public static void main(String[] args) {
        System.out.println(method()); //输出4
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

【例2】看下面代码，输出什么？

public class Exception02 {
    public static int method() {
        int i = 1;
        try {
            i++; //i=2
            String[] names = new String[3];
            if (names[1].equals("tom")) {//空指针
                System.out.println(names[1]);
            } else {
                names[3] = "hspedu";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            return 2;
        } catch (NullPointerException e) {//捕获异常
            return ++i; //执行++i，但不返回。此处i = 3
        } finally {//必须执行
            return ++i; //i = 4
        }
    }
    public static void main(String[] args) {
        System.out.println(method());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

【例3】看下面代码，输出什么？

public class ExceptionExe03{
    public static int method() {
        int i = 1;
        try {
            i++;// i=2
            String[] names = new String[3];
            if (names[1].equals("tom")) {//空指针
                System.out.println(names[1]);
            }else{
                names[3] = "hspedu";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            return 2;
        } catch (NullPointerException e) {
            return ++i;//i=3 =>保存临时变量temp=3;
        } finally {
            ++i;//i=4
            System.out.println("i=" + i);//i = 4
        }
    }
    public static void main(String[] args) {
        System.out.println(method());//3
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

  上面代码在捕获 NullPolnterException 异常时，“return ++i” 语句中，先执行 ++i，并将 i 值暂存于 temp，再执行必须执行的 finally。由于 finally 中没有 return 语句，所以会回到 catch 中返回，返回的是 temp。

输出结果：

i=4
3
1
2

【例4】如果用户输入的不是一个整数，就提示他反复输入，直到输入一个整数为止。

public class TryCatchExercise04 {
	public static void main(String[] args) {
        //如果用户输入的不是一个整数，就提示他反复输入，直到输入一个整数为止
        //思路
        //1. 创建 Scanner 对象
        //2. 使用无限循环，去接收一个输入
        //3. 然后将该输入的值，转成一个 int
        //4. 如果在转换时，抛出异常，说明输入的内容不是一个可以转成 int 的内容
        //5. 如果没有抛出异常，则 break 该循环
        Scanner scanner = new Scanner(System.in);
        int num = 0;
        while (true) {
            System.out.print("请输入一个整数:");
            String inputStr = scanner.next();
            try {
                num = Integer.parseInt(inputStr); //这里是可能抛出异常
                break;
            } catch (NumberFormatException e) {
                System.out.println("你输入的不是一个整数");
            }
        }
        System.out.println("你输入的值 = " + num);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

try-catch-finally 执行顺序小结：

• 如果没有出现异常，则执行 try 块中所有语句，不执行 catch 块中语句，如果有 finally，最后还需要执行 finally 里面的语句。
• 如果出现异常，则 try 块中异常发生后，try 块剩下的语句不再执行。将执行 catch 块中的语句，如果有 finally，最后还需要执行 finally 里的语句。

5. throws 异常处理

5.1 throws 基本介绍

  方法执行过程中，其中的语句可能产生异常，但有时可能不确定如何处理这些异常。这时，此方法应显式地抛出异常，表明该方法不处理这些异常，而由该方法的调用者处理。
  在方法声明中用 throws 语句可以声明抛出异常的列表，throws 后面的异常类型可以是方法中产生的异常类型，也可以是异常类型的父类。

public void f2() throws FileNotFoundException, NullPointerException, ArithmeticException {
     //创建了一个文件流对象
     //1.这里的异常是一个FileNotFoundException编译异常
     //2.可以使用try-catch-finally自行处理异常
     //3.也可以使用throws抛出异常，让f2的调用者（方法）处理
     //4.throws后面可以是产生的具体异常类型，也可以是异常类型的父类
     //5.throws后也可以是异常列表（多个异常名称），即可以抛出多个异常
     //6.抛出多个异常时，多个异常的名称可以用它们的共同父类（如Exception）代替
     FileInputStream fis = new FileInputStream("d://aa.txt");
 }
1
2
3
4
5
6
7
8
9
10

5.2 throws 使用细节

• 对于编译异常，程序中必须处理，比如 try-catch 或者 throws。

• 对于运行时异常，程序中如果没有处理，默认就是 throws 的方式处理。

  public static void f1() throws FileNotFoundException {
       //f2()方法抛出一个编译异常
       //调用者f1必须显式处理（try-catch或throws）
       f2(); 
   }
   public static void f2() throws FileNotFoundException {
       FileInputStream fis = new FileInputStream("d://aa.txt");
   }
   public static void f3() {
       //可以在f4()中直接调用f5()，因为f5()抛出的是运行异常
       // 运行异常默认throws，可以不用显式处理
       f4();
   }
   public static void f4() throws ArithmeticException {
       //f4抛出一个运行时异常
   }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

• 子类重写父类的方法时，对抛出异常的规定：子类重写的方法，所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常的类型的子类型。

  class Father{
      public void method() throws RuntimeException{
      }
  }
  class Son extends Father{
      @Override
      public void method() throws NullPointerException{
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9

• 在throws过程中，如果有方法 try-catch，就相当于处理异常，就可以不必 throws。

6. 自定义异常

  当程序中出现了某些 “错误”，但该错误信息并没有在 Throwable 子类中描述处理，这个时候可以自己设计异常类，用于描述该错误信息。

自定义异常的步骤：
（1）定义类：自定义异常类名（程序员自己写）继承 Exception 或 RuntimeException
（2）如果继承 Exception，属于编译异常
（3）如果继承 RuntimeException，属于运行异常（一般来说，继承 RuntimeException)

【例】当我们接收 Person 对象年龄时，要求范围在18 ~ 120之间，否则抛出一个
自定义异常（要求继承 RuntimeException)，并给出提示信息。

public class CustomException{
	//当自定义的异常继承RuntimeException时，这里不用显式地throws
    public static void main(String[] args) /*throws AgeException*/ {
        int age = 180;
        //要求范围在 18 ~ 120 之间，否则抛出一个自定义异常
        if(!(age >= 18 && age <= 120)) {
        	//相当于自己制造异常
        	//通过构造器，设置信息
            throw new AgeException("年龄需要在 18~120 之间");
        }
        System.out.println("你的年龄范围正确.");
    }
}
//自定义一个异常
//1. 一般情况下，我们自定义异常是继承RuntimeException
//2. 即把自定义异常做成 “运行时异常”，好处是可以不用显式地throws
class AgeException extends RuntimeException {
    public AgeException(String message) {//构造器
        super(message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输出结果：

7. throw 和 throws 的区别

【例1】下面代码输出什么？

【例2】
编写程序接收命令行的两个参数（整数），计算两数相除。
计算两个数相除，要求使用方法cal(int n1, int n2)
对数据格式不正确（NumberformatException)、缺少命令行参数
（ArraylndexOutOfBoundsException）、除0（ArithmeticException）进行异常处理。

public class Test {
    public static void main(String[] args){
        try {
            if (args.length != 2){
                throw new ArrayIndexOutOfBoundsException("参数个数不对");
            }
            int n1 = Integer.parseInt(args[0]);
            int n2 = Integer.parseInt(args[1]);
            int result = div(n1, n2);
            System.out.println("n1 / n2 = "+result);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e.getMessage());
        }catch (NumberFormatException e){
            System.out.println("数据格式不正确");
        }catch (ArithmeticException e){
            System.out.println("除以0的异常");
        }
    }
    public static int div(int n1, int n2){
        return n1 / n2;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

【例3】说出以下代码是否会发生异常，如果会，是哪种异常？如果不会，则打印结果是什么？

【例4】写出程序执行结果

【例5】写出程序执行结果