1. 异常
1.1 什么是异常
异常 ：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。
在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象或抛出了一个异常对象。Java处理异常的方式是中断处理。
1.2 异常的体系
异常机制其实是帮助我们找到程序中的问题，异常的根类是
java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常java.lang.Exception。
- Throwable体系
Error: 严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。
Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎。【我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。】
- 异常的分类：
编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)
1.3 异常的处理
1.3.1 JVM默认处理异常的方式
如果程序出现了问题，我们没有做任何处理，最终JVM 会做默认的处理
- 处理方式有如下两个步骤：
把异常的名称，错误原因及异常出现的位置等信息输出在了控制台
程序停止执行
- 代码示例：
public class ExceptionDemo {
public static void main(String[] args) {
int[] arr = { 34, 12, 67 };
int num = ArrayTools.getElement(arr, 4)
System.out.println("num=" + num);
System.out.println("over");
}
}
public class ArrayTools {
// 对给定的数组通过给定的角标获取元素。
public static int getElement(int[] arr, int index) {
int element = arr[index];
return element;
}
}- JVM处理异常过程分析
1.3.2 try-catch方式处理异常
定义格式：
try {
可能出现异常的代码;
} catch(异常类名 变量名) {
异常的处理代码;
}
执行流程：
程序从 try 里面的代码开始执行
出现异常，就会跳转到对应的 catch 里面去执行
执行完毕之后，程序还可以继续往下执行
代码示例：
public class ExceptionDemo01 {
public static void main(String[] args) {
int a = 10;
int b = 0;
//try存放的是可能出现问题的代码，如果有问题就进行catch，如果没有问题try和catch就不关心
try {
System.out.println("00000");
//try中里放的代码越少越好
System.out.println(a / b);
//这里不会执行
System.out.println("11111111111111111");
//异常类尽量准确
}catch (Exception e){
System.out.println("你不会数学，我来教你！！");
}
//处理完之后不影响后台代码执行
System.out.println("222222222222222");
}
}1.3.3 throws和 throw 处理异常
- 什么是声明异常（throws）
throws方式处理异常 又被称之为声明异常，将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。
关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).
声明异常格式
修饰符 返回值类型 方法名() throws 异常类名 {
}
- 什么是throw
在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。
在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？
创建一个异常对象。封装一些提示信息(信息可以自己编写。
需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。
throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
修饰符 返回值类型 方法名(参数列表) [throws 异常的类型] {
if (判断条件) {
throw new 异常对象("异常的原因");
}
}
代码示例：
public class ThrowsDemo {
public static void main(String[] args) throws FileNotFoundException {
read("a.txt");
}
// 如果定义功能时有问题发生需要报告给调用者。可以通过在方法上使用throws关键字进行声明
public static void read(String path) throws FileNotFoundException {
if (!path.equals("a.txt")) {//如果不是 a.txt这个文件
// 我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw
throw new FileNotFoundException("文件不存在");
}
}
}- throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。
public class ThrowsDemo2 {
public static void main(String[] args) throws IOException {
read("a.txt");
}
public static void read(String path)throws FileNotFoundException, IOException {
if (!path.equals("a.txt")) {//如果不是 a.txt这个文件
// 我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw
throw new FileNotFoundException("文件不存在");
}
if (!path.equals("b.txt")) {
throw new IOException();
}
}
}- Exception大的异常
public class Demo {
public static void main(String[] args) throws Exception {
read("a.txt");
}
public static void read(String path)throws Exception {
if (!path.equals("a.txt")) {//如果不是 a.txt这个文件
// 我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw
throw new FileNotFoundException("文件不存在");
}
if (!path.equals("b.txt")) {
throw new IOException();
}
}
}1.3.4 throw 与 throws的区别
1.throw代表动作,表示抛出一个异常的动作; throws代表一种状态,代表方法可能有异常抛出
2.throw用在方法实现中,而throws用在方法声明中
3.throw只能用于抛出一种异常,而throws可以抛出多个异常
2. Throwable类中常见方法
| 方法名 | 说明 |
|---|---|
| String getMessage() | 获取的异常的原因 |
| String toString() | 获取的是异常的类型和原因 |
| void printStackTrace() | 获取的是异常的类型 原因 和位置 |
代码示例：
public class ExceptionDemo5 {
public static void main(String[] args) {
show();
}
public static void show(){
int a = 1;
int b = 0;
int c =0;
try {
//会执行
System.out.println("你好世界");
//注意事项：1、try的作用范围 2、在try中尽量少放代码
c = a/b;
//不会执行，以上的代码出错了
System.out.println("你好朋友");
} catch (Exception e) {
e.printStackTrace(); //错误信息输出最完整方法，常用
// System.out.println( e.getMessage() );// by zero
// System.out.println(e.toString()); //java.lang.ArithmeticException: / by zero
}
System.out.println(c);
System.out.println("啦啦啦啦");
}
}3. finally 代码块
- 什么是 finally
有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
【注】finally不能单独使用。必须配合着try...catch使用 。
- finally格式
try {
可能出现异常的代码;
。。。
} catch(异常类名 变量名) {
异常的处理代码;
} finally{
释放资源
}代码示例：
public static void main(String[] args) {
try {
int[] arr = {1,2,3};
System.out.println(arr[3]);
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("finally代码块执行了.....");
}
}【注】当只有在try或者catch中调用退出JVM的相关方法,此时finally才不会执行,否则finally永远会执行。
4. 异常的注意事项
- 多个异常使用捕获又该如何处理呢？
多个异常分别处理。
多个异常一次捕获，多次处理。
多个异常一次捕获一次处理。
一般我们是使用一次捕获多次处理方式，格式如下：
try{
编写可能会出现异常的代码
}catch(异常类型A e){ // 当try中出现A类型异常,就用该catch来捕获.
处理异常的代码
//记录日志/打印异常信息/继续抛出异常
}catch(异常类型B e){ // 当try中出现B类型异常,就用该catch来捕获.
处理异常的代码
//记录日志/打印异常信息/继续抛出异常
}
/*注意:这种异常处理方式，要求多个catch中的异常不能相同，
并且若catch中的多个异常之间有子父类异常的关系，
那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。*/
运行时异常被抛出可以不处理。即不捕获也不声明抛出。
如果finally有return语句,永远返回finally中的结果,避免该情况。
如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
/**
* 注意事项：
* 1:能明确的尽量明确，不要用大的来处理。
* 2:平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面。
*/
public class Demo {
public static void main(String[] args){
int a = 10;
int b = 0;
int[] arr = {1,2,3};
try {
// System.out.println(a/b);
System.out.println(arr[3]);
} catch (ArithmeticException ae) {
ae.printStackTrace();
System.out.println("我是算术异常");
} catch (ArrayIndexOutOfBoundsException ae) {
ae.printStackTrace();
System.out.println("我是数组异常");
} catch (Exception e ){
e.printStackTrace();
System.out.println("我是异常");
}
}
public static void main(String[] args) {
int a = 10;
int b = 0;
int[] arr = {1,2,3};
try {
System.out.println(a/b);
System.out.println(arr[9]);
//。。。。异常
} catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
}catch (Exception e) {
e.printStackTrace();
}
}
}-
如果在finally之前有return
/*
* 面试题：
* 2:如果catch里面有return语句，请问finally里面的代码还会执行吗?
* 如果会，请问是在return前，还是return后。
* 会。前。
*/
public static void main(String[] args) {
System.out.println(getInt());
}
public static int getInt() {
int a = 10;
try {
System.out.println(a / 0);
a = 20;
} catch (ArithmeticException e) {
a = 30;
return a;
/*
* return a在程序执行到这一步的时候，这里不是return a而是return 30;这个返回路径就形成了。
* 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
* 再次回到以前的返回路径，继续走return 30;
*/
} finally {
System.out.println("我是finally");
}
return a;
}运行结果：
5. 自定义异常
- 什么是自定义异常类
一个类继承了
java.lang.Exception或java.lang.RuntimeException类，那么这个类就是一个异常类
- 自定义异常类格式
public class 异常类 extends Exception | RuntimeException {
public 异常类() {
}
public 异常类(String message) {
super(message);
}
}- 自定义异常代码实现
需求：
自定义一个业务逻辑异常: RegisterException类，模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。
异常类RegisterException定义
// 业务逻辑异常
public class RegisterException extends Exception {
/** 空参构造 */
public RegisterException() {
}
/**
* @param message 表示异常提示 */
public RegisterException(String message) {
super(message);
}
}业务逻辑代码实现
public class Demo {
// 模拟数据库中已存在账号
private static String[] names = {"bill","hill","jill"};
public static void main(String[] args) {
//调用方法
try{
for(int x = 0; x <names.length; x++){
if(names[x].equals("bill")){//如果名字在这里面 就抛出登陆异常
throw new RegisterException("亲"+names[x]+"已经被注册了！");
}
}
}catch(RegisterException e){
//处理异常
e.printStackTrace();
}
}
}