java_day08：异常（try catch finally异常处理机制）理解与应用

最新推荐文章于 2024-07-14 22:18:32 发布

“呦呦鹿鸣”

最新推荐文章于 2024-07-14 22:18:32 发布

阅读量214

点赞数

分类专栏： Java 笔记心得文章标签： java 异常 try...catch...finally 异常处理机制

本文链接：https://blog.csdn.net/qq_45024094/article/details/100546840

版权

Java 同时被 3 个专栏收录

13 篇文章 0 订阅

订阅专栏

笔记

12 篇文章 0 订阅

订阅专栏

心得

9 篇文章 0 订阅

订阅专栏

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");
	}
}

“呦呦鹿鸣”

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java_day08：异常（try catch finally异常处理机制）理解与应用

1.异常1.异常概述1.1 异常的引入现实生活中万物在发展和变化会出现各种各样不正常的现象。1.2 异常发生的原因**核心：**在有问题代码出现的地方，默认创建并抛出一个异常现象，改异常对象中封装好了异常的描述信息，然后默认交给方法的调用者来处理！1.4.使用throw抛出异常在代码有问题地方，使用throw关键字抛出一个异常对象，该异常对象中包含了异常的描述信息。1.5.自定义异...
复制链接

扫一扫