4.2.2 try 和 catch 关键字
通过上述的 throws 的讲解，我们发现他并没有真正的解决异常，而是将异常报告给抛出异常方法的调用者，由调用者去解决，如果一层层往上抛，最终会交给JVM解决，所以我们如果要真正的解决异常，就需要使用 try - catch 关键字：
语法格式：
try {
// 将可能出现异常的代码放在这里
} catch(要捕获的异常类型 ex) {
// 对捕获的异常进行处理
}
如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，或者是try中抛出异常的基类 时，就会被捕获到，对异常就可以正常处理，处理完成后，跳出 try - catch 结构，继续执行后序代码！
这里 try 代码块中也可能不会抛出异常！
这里我们举一个例子，上面写过获取数组对应下标的值，这里我们就改造一下，获取对应数组两个下标的值，把这两个值放到 ret 数组中并返回，首先这个程序是可能会出现异常的，比如传过来的数组是 null，或者获取的下标越界了，我们就考虑这两个异常，那么改如何实现这个代码呢？
public class TestDemo { public static int[] getArrayValue (int[] array, int index1, int index2) { int[] ret = new int[2]; try { ret[0] = array[index1]; ret[1] = array[index2]; return ret; } catch (NullPointerException ex) { System.out.println("getArrayValue::传递的数组为空！"); ex.printStackTrace(); } catch (ArrayIndexOutOfBoundsException ex) { System.out.println("getArrayValue::数组下标越界了！"); ex.printStackTrace(); } System.out.println("测试抛出异常捕获并处理后会不会执行后续代码！"); return null; } public static void main(String[] args) { int[] array = { 1,2,3,4,5 }; int[] ret = getArrayValue(array, 3, 10); System.out.println(Arrays.toString(ret)); } }
如果我们执行这个 main 方法的话，捕获到的会是数组越界的异常，而捕获到之后，还会不会执行此方法后续的代码呢？我们来运行看答案：
通过测试我们发现，我们捕获的确实是数组越界异常，而仍然可以执行后续的代码，而且程序是正常退出！那么这就是捕获并处理异常，这样做的好处是什么？我们不会因为一个异常而终止我整个程序的运行！对于不太严重的问题，可以记录错误日志，通过监控报警程序可以及时通知程序员，对于可能会恢复的问题(网络相关的场景)，可以进行重试。
那么看到这，或许有的小伙伴有一个问题，那要是我上面的 main 方法传过去的是空数组并且越界还越界了呢？会抛出两个异常吗？
答案是不会的！在很前面我们就介绍了，当程序抛出异常，中断程序，但是这里我们捕获了异常，所以在 try 代码块内，try 中抛出的异常之后的代码不会执行，直接去 catch 去匹配，只要捕获了，后面代码就可以执行，上述例子输出也能看得出来。
注意：
如果抛出的异常与 catch 时异常类型不匹配，即异常不会被成功捕获，也不会被处理，继续往外抛，直到 JVM 收到后中断程序，异常是按类型来捕捉的！
如果上述情况异常的处理方式是相同的，我们在 catch 中也可也这样写：
//数组越界异常或空指针异常 catch (ArrayIndexOutOfBoundsException | NullPointerException ex) { //...code }
那么既然数组越界异常和空指针异常的父类都是 Exception 类，那么能不能直接一次性捕获多个异常呢？由于 Exception 类是所有异常类的父类，因此可以用这个类型表示捕捉所有异常，没有任何问题，但是不推荐！这样代码的可读性会大大降低！
//一次性捕获多个异常 catch (Exceptionn ex) { //...code }
注意：catch 进行类型匹配的时候, 不光会匹配相同类型的异常对象, 也会捕捉目标异常类型的子类对象
那么我们推荐怎么写呢？如果异常之间具有父子关系，一定是子类异常在前面的 catch，父类异常在后面的 catch 不然语法会报错，因为如果父类异常在前，表示着出异常永远不会走到子类异常那里去，如果从逻辑上讲，你就可以这么理解，当我们前面所有的子类都没有捕获到这个异常，我们再交给父类去解决，如下演示：
public static int[] getArrayValue (int[] array, int index1, int index2) { int[] ret = new int[2]; try { ret[0] = array[index1]; ret[1] = array[index2]; return ret; } catch (NullPointerException ex) { System.out.println("getArrayValue::传递的数组为空！"); ex.printStackTrace(); } catch (ArrayIndexOutOfBoundsException ex) { System.out.println("getArrayValue::数组下标越界了！"); ex.printStackTrace(); } catch (Exception ex) { //前面我们考虑的异常都没有捕获最后再交给父类解决 ex.printStackTrace(); } System.out.println("测试抛出异常捕获并处理后会不会执行后续代码！"); return null; }
4.2.3 finally 关键字
在写程序时，有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库 连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。另外，因为异常会引发程序的跳转，可能 导致有些语句执行不到，finally就是用来解决这个问题的。
语法格式：
try {
// 可能会发生异常的代码
} catch(要捕获的异常类型 ex) {
// 对捕获到的异常进行处理
} finally {
// 此处的语句无论是否发生异常，都会被执行到
}
//...code 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行
在我们上面的学习中，只要异常被捕获了，try - catch 后面的代码也可也执行，那为什么还需要 finally 呢？
这里我们用一个例子来看一下，实现一个 getData 方法，方法内部输入一个数字，并返回这个数字：
public static int getData() { Scanner scanner = null; try { scanner = new Scanner(System.in); int data = scanner.nextInt(); return data; } catch (InputMismatchException ex) { ex.printStackTrace(); } finally { System.out.println("finally中代码"); } System.out.println("try-catch-finally之后代码"); if (null != scanner) { scanner.close(); } return 0; }
那这里我们有一个问题，如果你是正常输入的，那么将会直接返回 data，并不会走到后面的代码，也就是不会释放输入流，造成资源浪费，所以我们可以把释放输入流语句放到 finally 中，因为 不管是否抛出异常，是否被捕获，finally 中的语句都会被执行。
finally 中的代码一定会执行的，一般在 finally 中进行一些资源清理的扫尾工作。
4.2.4 finally 的执行时机是什么？
我们先来看下面这段代码：
public class TestDemo { public static int func() { try { return 1; } finally { return 2; } } public static void main(String[] args) { System.out.println(func()); } }
首先我们要弄清楚，finally 执行的时机是在方法返回之前，如果 try 或 catch 中有 return 语句，会在这个 return 之前执行 finally，如果 finally 中也存在 return 语句，那么就会执行 finally 中的 return 从而不会执行 try 或 catch 原有的 return，一般我们不建议在 finally 中写 return 语句，会被编译器当成是一个警告！
4.3 异常处理的流程
先是执行 try 中的代码，如果里面的代码发生了异常，就会立刻结束 try 中的代码，不会执行 try 中后续代码，接着会去看 catch 中的异常类型与 try 中发生异常的类型能否匹配，如果找到了匹配的异常类型，则会执行对应 catch 中的代码，如果没有找到匹配的异常类型，就会将异常向上传递到上层调用者，无论是否发生异常，是否匹配，finally 中的代码都会在方法结束前执行！如果上层调用者也没有处理这个异常，就继续向上传递，一直到 main 方法也没有合适的代码处理，就会交给 JVM 来进行处理，这个时候，程序就会异常终止！
5、自定义异常类
有了上面的学习，我们发现Java中的异常其实都是类，虽然提供很多的异常类，但是不能完全满足我们在开发中的需求，所以就需要我们自定义一些异常类，维护符合我们实际情况的一个异常结构，假设说这里我们模拟简单实现一个登录功能：
这里我们就先输入用户名，再输入密码，这里的逻辑怎么做呢？假设用户名错误，就不会去判断密码是否正确，就直接抛出用户名错误异常，只有用户名匹配上了，我们再去判断对应的密码是否正确，如果不正确，则抛出密码错误异常。
那么具体怎么自定义一个异常呢？
- 自定义一个类，然后继承 Exception 或者 RuntimeException 类
- 实现一个带有 String 类型参数的构造方法，参数也就是出现异常的原因
这里我们就简单的照葫芦画瓢自定义一个异常类：
public class UserNameException extends RuntimeException { public UserNameException(String message) { super(message); } }
这里可以看到这个异常类我们继承了 RuntimeException 异常类，接着里面有一个构造方法，调用父类的构造传递了一个字符串，至于父类的实现我们目前可以不管，那么这样，就简单的自定义了一个异常类，现在我们模拟实现下登录系统：
public class TestDemo { class UserNameException extends RuntimeException { public UserNameException(String message) { super(message); } } class UserPasswordException extends RuntimeException { public UserPasswordException(String message) { super(message); } } class Login { private String userName = "Mike"; private String userPassword = "123456"; public void loginInfo(String userName, String userPassword) { if (!this.userName.equals(userName)) { throw new UserNameException("用户名错误！"); } else if (!this.userPassword.equals(userPassword)) { throw new UserPasswordException("用户密码错误！"); } } } public static void main(String[] args) { Login login = new Login(); while (true) { Scanner scanner = new Scanner(System.in); System.out.print("请输入用户名: "); String name = scanner.nextLine(); System.out.print("请输入密码: "); String password = scanner.nextLine(); try { login.loginInfo(name, password); break; } catch (UserNameException ex) { ex.printStackTrace(); } catch (UserPasswordException ex) { ex.printStackTrace(); } System.out.println("登录失败，请重新登录！"); } System.out.println("登陆成功，执行后续代码...."); } }
测试结果：
以上代码就是在 loginInfo 方法中可能会抛出用户名错误或者密码错误的异常，然后在 main 方法中去处理了这个异常，直到输入正确才执行 main 方法后续的代码，这只是简单的巩固下异常的运用。
注意：
如果自定义异常类继承了 Exception类，默认是受检查异常(编译时异常)
如果自定义异常类继承了 RuntimeException，默认是不受检查异常(运行时异常)
