1.异常
1.异常概述
1.1 异常的引入
现实生活中万物在发展和变化会出现各种各样不正常的现象。
1.2 异常发生的原因
**核心:**在有问题代码出现的地方,默认创建并抛出一个异常现象,改异常对象中封装好了异常的描述信息,然后默认交给方法的调用者来处理!
1.4.使用throw抛出异常
在代码有问题地方,使用throw关键字抛出一个异常对象,该异常对象中包含了异常的描述信息。
1.5.自定义异常
需求:给学生年龄赋值,当学生年龄不合法的时候,我们抛出一个“年龄越界异常”!
解决:因为java中提供的异常不包含“年龄越界异常”,所以我们应该自定义一个异常类。
什么时候需要自定义异常????
当java中提供的异常不能满足实际开发需求时,那么我们就应该自定义异常。
怎么去自定义异常类呢???
自定义异常类必须继承于异常体系,一般情况下我们继承于Exception类或RuntimeException类即可。
自定义异常的注意点
1)自定义异常一定需要提供两个构造方法,一个无参构造方法,另外一个是带详细异常描述的构造方法。
2)自定义异常必须继承于异常体系,只有继承于异常体系的类,那么才能使用throw和throws关键字
public class Test02 {
public static void main(String[] args) throws AgeOutOfBoundsException {
Student stu = new Student();
stu.setAge(-18);
}
}
public class Student {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
// 要求:年龄不能为负数||年龄不能大于250
public void setAge(int age) throws AgeOutOfBoundsException {
if(age < 0 || age > 250) {
throw new AgeOutOfBoundsException("年龄越界异常:" + age);
}
else {
this.age = age;
}
}
}
/**
* 年龄越界异常类
*/
public class AgeOutOfBoundsException extends Exception {
public AgeOutOfBoundsException() {
super();
}
public AgeOutOfBoundsException(String message) {
super(message);
}
}
2.异常的分类
思考:
“年龄越界异常”继承于Exception和RuntimeException的区别???
通过测试我们发现,继承于Exception和RuntimeException是有区别的,这就引申出来了异常分类!
2.1.异常的分类
a)运行时异常(Runtime Exception) —> 运行时出现
RuntimeException类及其子类都属于运行时异常。
特点:在编译时,不强制我们对程序中出现的异常进行处理(可以处理,也可以不处理)
b)编译时异常(Checked Exception) —> 编译时出现
Exception类及其子类(不包含运行异常类)都属于编译时异常。
特点: 在编译时,强制我们对程序中出现的异常进行处理(强制处理)
2.2.关于Throwable分类的补充
a)Error和运行时异常,在编译时不能被检查出来,所以我们有称之为:不可检查异常(UnChecked Exception)。
b)编译时异常,在编译时能够被检查出来,所以我们有称之为:可检查异常(Checked Exception)。
2.3.异常处理的方式
a)声明异常(throws),就是消极处理异常的方式
b)捕捉异常(try…catch…finally),就是积极处理异常的方式
2.4.异常的处理之声明异常(throws)
当方法体中出现了异常,而此时我们在方法体中又不能处理该异常,那么我们可以把方法体中出现的异常使用
throws关键字声明在方法上面,然后【报告给方法的调用者】,交于方法的调用者来处理。
语法:[修饰符] 返回值类型 方法名(形参列表) throws 异常类1, 异常类2, 异常类3, … {
// 方法体
}
注意事项:
1)声明异常(throws),就是消极处理异常的方式。当方法体中出现的异常我们不能处理的时候,可以把该异常声明在方法上面,交给方法的调用者来解决。
2)如果方法体中抛出了多个异常对象,那么我们应该在方法声明上面throws多个异常类,多个异常类之间以“逗号”分割!
2.5.throw和throws的区别
位置区别
throw:在方法体中
throws:在方法声明上面,并且在最后面
内容区别
throw:抛出的是异常对象,只能排除一个异常对象!
throws:声明的是异常类,可以声明多个异常类!
本质区别
throw:抛出异常对象,只要执行了throw关键字,那么肯定就会抛出一个异常对象!
throws:声明异常类,声明方法中可能会发生异常,但是未必一定会发生异常情况
class ArrayUtil {
/**
* 根据索引获取数组对应元素值
* @param arr 数组
* @param index 索引
* @return 返回值
* @throws NullPointerException
* @throws ArrayIndexOutOfBoundsException
*/
public static int get(int[] arr, int index) throws NullPointerException, ArrayIndexOutOfBoundsException{
// 问题代码1,空指针异常
if (null == arr) {
throw new NullPointerException("arr为null");
}
// 问题代码2,索引越界异常
if(index < 0 || index >= arr.length) {
throw new ArrayIndexOutOfBoundsException(index);
}
// 正常逻辑代码
int value = arr[index];
System.out.println("value:" + value);
return value;
}
}
public class Test02 {
public static void main(String[] args) {
int[] arr = {11, 22, 33};
ArrayUtil.get(arr, 1);
// int[] arr = new int[1024*1024*1024];
}
}
3.异常处理
异常的处理方式之捕捉异常(try…catch…finally)
注意:该方式是积极的处理方式。
3.1.try…单catch
语法:try {
// 书写可能出现异常的代码
}
catch(异常类 对象) {
// 对try代码块中捕捉到的异常进行处理
}
注意:在控制台“打印堆栈异常信息”未必意味着程序结束!
public class Test01 {
public static void main(String[] args) {
Student stu = new Student();
try {
stu.setAge(-18); // throw new AgeOutOfBoundsException("年龄越界异常:" + age)
System.out.println("try over ...");
}
catch(AgeOutOfBoundsException exception) {
// 对出现的异常进行处理!
// System.out.println("getMessage:" + exception.getMessage()); // 输出异常信息
// System.out.println("toString:" + exception.toString()); // 输出异常对象
exception.printStackTrace(); // 在控制台打印堆栈异常信息
}
// 前面无论有没有异常,此处的代码都会正常执行
System.out.println("main over ...");
}
}
public class Student {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
// 要求:年龄不能为负数||年龄不能大于250
public void setAge(int age) throws AgeOutOfBoundsException, NullPointerException {
if(age < 0 || age > 250) {
throw new AgeOutOfBoundsException("年龄越界异常:" + age);
}
else {
throw new NullPointerException();
// this.age = age;
}
}
}
public class ArrayUtil {
public static int get(int[] arr, int index) throws NullPointerException, ArrayIndexOutOfBoundsException{
// 问题代码1,空指针异常
if (null == arr) {
throw new NullPointerException("arr为null");
}
// 问题代码2,索引越界异常
if(index < 0 || index >= arr.length) {
throw new ArrayIndexOutOfBoundsException(index);
}
// 正常逻辑代码
int value = arr[index];
return value;
}
}
3.2.try…多catch
一个try可以对应多个catch,这样就实现了对不同的异常信息做正对性的处理!
语法: try {
// 书写可能出现异常的代码
}
catch(异常类1 对象1) {
// 对try代码块中捕捉到的异常进行处理
}
catch(异常类2 对象2) {
// 对try代码块中捕捉到的异常进行处理
}
....
注意事项
1)如果遇到多catch的情况,一定要把父类异常的catch放在最后面,因为catch是从上往下依次开始匹配的。
2)多catch情况,如果我们对出现的多个异常做相同的处理,那么还可以这么做:
catch (ArrayIndexOutOfBoundsException | NullPointerException | AgeOutOfBoundsException e){}
class AAExcpetion extends Exception {}
class BBExcpetion extends AAExcpetion {}
class CCExcpetion extends BBExcpetion {}
class Demo {
public void method(int index) throws AAExcpetion, BBExcpetion, CCExcpetion {
if(index == 1) {
throw new AAExcpetion();
}
else if(index == 2) {
throw new BBExcpetion();
}
else {
throw new CCExcpetion();
}
}
public void start(int index) throws AgeOutOfBoundsException, NullPointerException, ArrayIndexOutOfBoundsException {
if(index == 0) {
throw new NullPointerException();
}
else if(index == 1) {
throw new AgeOutOfBoundsException();
}
else {
throw new ArrayIndexOutOfBoundsException();
}
}
}
public class Test02 {
public static void main(String[] args) {
// 注意事项(二)
try {
new Demo().start(0);
} catch (ArrayIndexOutOfBoundsException | NullPointerException | AgeOutOfBoundsException e) {
e.printStackTrace();
}
/*// 注意事项(一)
try {
new Demo().method(0);
} catch (CCExcpetion e) { // 孙子辈
e.printStackTrace();
} catch (BBExcpetion e) { // 儿子辈
e.printStackTrace();
} catch (AAExcpetion e) { // 父亲辈
e.printStackTrace();
}*/
// try...多catch演示
/*int[] arr = {11, 22, 33};
try {
int value = ArrayUtil.get(null, 2); // throw new NullPointerException("arr为null");
System.out.println("value:" + value);
}
catch(NullPointerException e) { // 专门用于捕捉空指针异常及其空指针异常的子类
e.printStackTrace();
}
catch (ArrayIndexOutOfBoundsException e) { // 专门用于索引越界异常及其索引越界异常的子类
e.printStackTrace();
}
System.out.println("over");*/
}
}
3.3.try…catch…finally
语法:try {
// 书写可能出现异常的代码
}
catch(异常类1 对象) {
// 对try代码块中捕获到的异常进行处理
}
catch(异常类2 对象) {
// 对try代码块中捕获到的异常进行处理
}
......
finally {
// 无论try代码块中是否发生异常,finally代码块都会执行
}
注意事项:
1)即便是try或catch中存在return关键字,会先执行finally代码块中的代码,然后再结束方法!
只有在try或catch中执行结束虚拟机(JVM)的操作,也就是执行“System.exit(0)”代码,那么finally才不会执行!
2)因为程序无论是否发生异常,finally中的代码都会执行,所以我们一般在finally中执行关闭资源的操作。
3)例如:关闭数据库、关闭IO流等等
public class Test03 {
public static void main(String[] args) {
int[] arr = {11, 22, 33};
try {
int value = ArrayUtil.get(null, 0);
System.out.println(value);
// return; // 结束方法,此处结束方法之前会去执行finally中的代码,当finally中的代码块执行完毕才会结束方法
System.exit(0); // 结束虚拟机,结束程序!
}
catch(NullPointerException e) {
e.printStackTrace();
System.exit(0); // 结束虚拟机,结束程序!
}
catch(ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
return; // 结束方法,此处结束方法之前会去执行finally中的代码,当finally中的代码块执行完毕才会结束方法
}
// 只要没有结束虚拟机,那么finally肯定会执行
finally {
System.out.println("无论是否发生异常,finally代码块都会执行");
}
// 在有些场合,未必会一定执行
System.out.println("over");
}
}
3.4.try…finally
语法:try {
// 书写可能出现异常的代码
}
finally {
// 关闭资源的操作
}
使用场合:在try发生异常,但是我们自己无法处理,所以把该异常声明在方法上面,交给调用者来处理该异常。
因为在try中执行了打开资源的操作,所以我们需要finally来关闭资源。
3.5.关于异常处理的总结
3.5.1异常的处理方式有哪些???
a)声明异常(throws),消极处理的方式
b)捕捉异常(try…catch…finally),积极处理的方式
3.5.2哪些异常需要我们处理???
a)编译时异常,我们必须在编译时期就进行处理(必须处理)
b)运行时异常,我们可以在编译时期处理,也可以在编译时期不处理(可以处理,也可以不处理)
3.5.3什么时候使用声明异常(throws)??? 什么时候使用捕捉异常(try…catch…finally)???
a)当程序发生了异常,但是我们自己又处理不了的时候,可以把该异常声明在方法上,交给调用者来处理该异常。
b)当程序发生了异常,我们自己有能处理该异常的时候,就不要把该异常继续往上声明了,而是主动的来解决这个异常。
e.toString(): 获得异常种类和错误信息
e.getMessage():获得错误信息
e.printStackTrace():在控制台打印出异常种类,错误信息和出错位置等
class Test {
public static void start(int index) throws AgeOutOfBoundsException {
if(index == 0) {
throw new AgeOutOfBoundsException();
}
}
}
public class Test04 {
public static void main(String[] args) throws AgeOutOfBoundsException
int[] arr = {11, 22, 33};
try {
// 此处抛出的异常我们无法解决,所以把异常声明在方法上面,交给方法的调用者来处理,
// 又因为此处打开了数据库资源的操作,所以我们需要在finally中关闭数据库连接!
Test.start(0);
}
finally {
System.out.println("无论是否发生异常,finally代码块都会执行");
}
// 在有些场合,未必会一定执行
System.out.println("over");
}
}