29 异常处理和finally关键字

异常处理

异常的定义

异常就是指的程序在运行过程中，发生的不正常（用户操作不当、服务终止、程序BUG…)的程序无法正常运作的情况

异常举例

package com.openlab.day13.exception;

public class TestException {
	
	public static void main(String[] args) {
		int a = division(8,0);
		System.out.println(a);
	}
	
	//除法
	private static int division(int i, int j) {
		return i/j;
		
	}

}

异常处理的目的

为了提高程序的容错能力、稳定性和健壮性，让程序正常的运作下去

Java如何处理异常

抓捕异常（推荐）

尝试着抓到对应的异常，在针对具体问题，具体处理

抓捕异常格式

try {
//代码块
}catch(XxxException e）{
//处理异常
}catch(XxxException e）{
//处理异常
}finally{
}

抓捕异常举例

package com.openlab.day13.exception;

public class TestException {
	
	public static void main(String[] args) {
		int a = division(8,0);
		System.out.println(a);
	}
	
	//除法
	private static int division(int i, int j) {
		int a = 0;
		
		try {
			//尝试着抓捕异常
			a = i/j;
		}catch(ArithmeticException e) {
			System.out.println("触发了数学异常");
		}
		
		return a;
		
	}

}

抓捕异常补充

try语法块如果没有抓捕到异常，程序正常执行，catch语法块不会进入！如果try中某行代码触发了异常，则程序立刻进入到对应的异常处理块（catch）中，进行异常处理

多个异常

抛出异常

向上抛出，由上层解决
方法名字后面 throws 异常名称{
}

举例

Java异常类的继承关系

异常对象的使用

当异常被捕获到时，异常对象就会自动创建
e.getMessage() //输出异常信息
e.printStackTrace() //在控制台上打印输出异常的错误情况（调用栈情况）

自定义异常类的使用

在项目开发时，一般一个项目需要自定义一个异常，用来传递信息
在Java中，自定义异常非常简单，只要继承了Exception类即可，该类就是一个异常类

package com.openlab.day13.exception;

public class MyException extends RuntimeException {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public MyException() {
		super();
		
	}

	public MyException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
		
	}

	public MyException(String message, Throwable cause) {
		super(message, cause);
		
	}

	public MyException(String message) {
		super(message);
		
	}

	public MyException(Throwable cause) {
		super(cause);
		
	}
	
}

人为的抛出异常

throw关键字抛出异常

package com.openlab.day13.exception;

public class Test02 {
	
	public static void main(String[] args) {
		add(-1,0);
		
	}

	private static int add(int a, int b) {
		if (a < 0 || b < 0) {
			throw new RuntimeException("两个数都必须是正数");
		}
		int c = a + b;
		return c;
		
	}

}

package com.openlab.day13.exception;

public class Test02 {
	
	public static void main(String[] args) {
		try {
			add(-1,0);
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		
		System.out.println("123456789");
	}

	private static int add(int a, int b) {
		if (a < 0 || b < 0) {
			throw new RuntimeException("两个数都必须是正数");
		}
		int c = a + b;
		return c;
		
	}

}

异常的分类

运行时异常

继承了RuntimeException的异常
特点：只有在运行时才能知道是否会有异常

非运行时异常（编译型异常）

特点：在编译时，就会报错，必须处理

finally关键字

1 特点

不管是否存在异常，finally部分必须要执行

try{
}finally{
//重要的，必须要执行的，如资源的释放、垃圾的回收等等
}

package com.openlab.day13.exception;

import java.util.Scanner;

public class TestFinally {
	
	public static void main(String[] args) {
		test01();
		
		try {
			
		}finally {
			//必须要执行的部分
		}
	}
	
	public static void test01() {
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入一个整数：");
		int num = 0;
		try {
			num = sc.nextInt();
		} catch (Exception e) {
			
			e.printStackTrace();
		}finally {
			//这是必须要执行的代码
			//必须要执行的代码，就可以放在这
			System.out.println("这个是finally 部分");
			sc.close();
		}
		System.out.println("你输入的是：" + num);
	}
}

请输入一个整数：欧克
java.util.InputMismatchException
这个是finally 部分
你输入的是：0
	at java.base/java.util.Scanner.throwFor(Scanner.java:939)
	at java.base/java.util.Scanner.next(Scanner.java:1594)
	at java.base/java.util.Scanner.nextInt(Scanner.java:2258)
	at java.base/java.util.Scanner.nextInt(Scanner.java:2212)
	at com.openlab.day13.exception.TestFinally.test01(TestFinally.java:22)
	at com.openlab.day13.exception.TestFinally.main(TestFinally.java:8)

2 finally和return 共同作用

package com.openlab.day13.exception;

public class Test01 {
	
	public static void main(String[] args) {
		int num = test04();
		System.out.println(num);
	}

	private static int test04() {
		int num = 10;
		try {
			System.out.println(num);
			//在函数中，如果在finally之前，使用return关键字
			//则在return完成前，执行finally,在return
			return  num + 1;
		}catch(Exception e) {
			System.out.println("发生异常");
		}finally {
			System.out.println("必须要执行的代码");
		}
		return num + 2;
		
	}

}

注：最终的返回值没有被num++影响，因为在执行finally之前，return的值就已经定下来了