学习Java第十七天

Java异常

什么是异常

  • 错误在我们编写程序过程中经常发生,包括编译期间和运行期间的错误

运行期间错误
在这里插入图片描述

  • 在程序运行过程中,意外发生的情况,背离我们程序本身的意图的表现,都可以理解为异常

异常分类

  • Throwable有两个重要的子类:Eexeption 和 Error

在这里插入图片描述

Error

  • Error是程序无法处理的错误,表示运行应用程序中较严重的问题。大多数错误与代码编写者的执行操作无关,而表示代码运行时的JVM(Java虚拟机)出现的问题
  • 例如,Java虚拟机运行错误(virtual MachineError),当JVM不再有继续执行操作所需的内存资源时,将出现OutOfMemoryError
  • 这些错误是不可查的,因为它们在应用程序的控制和处理能力之外,而且绝大多数是程序运行时不允许出现的状况
  • 对于设计合理的应用程序来说,即使确实发生了错误,本质上也不应该试图去处理它所引起的异常状况
  • 因此我们编写程序时不需要关心这类异常

Exception

  • Exception 是程序本身可以处理的异常,异常处理通常只针对这种类型异常的处理
  • Exception 类的异常包括 checked exception 和 unchecked exception
unchecked exception
  • unchecked exception:编译器不要求强制处理的异常
  • 包含RuntimeException 类及其子类异常
  • 如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等,这些异常是unchecked exception
  • Java编译器不会检查这些异常,在程序中可以选择捕获处理,也可以不处理,照样正常编译通过
checked exception
  • checked exception:编译器要求必须处理的异常
  • 要RuntimeException 及其子类以外,其他的Exception子类
  • 如IOException、SQLException等
  • Java编译器会检查这些异常,当程序中可能出现这类异常时,要求必须进行异常处理,否则编译不会通过

异常处理

在Java应用程序中,异常处理机制为:抛出异常、捕获异常

抛出异常

在这里插入图片描述

  • 当一个方法出现错误引发异常时,方法创建异常对象并交付运行时系统
  • 异常对象中包含了异常类型和异常出现时的程序状态等异常信息
  • 运行时系统负责寻找处置异常的代码并执行

捕获异常

  • 在方法抛出异常之后,运行时系统将转为寻找合适的异常处理器
  • 运行时系统从发生异常的方法开始,依次回查调用栈中的方法,当异常处理器所能处理的异常类型与方法抛出的异常类型相符时,即为合适的异常处理器
  • 当运行时系统遍历调运栈而未找到合适的异常处理器,则运行时系统终止。同时,意味着Java程序的终止
  • 对于运行时的异常,错误或可查异常,Java技术所要求的异常处理方式有所不同
    在这里插入图片描述
    简单来说,异常总是先被抛出,后被捕捉

通过5个关键字实现:try、catch、finally、throw、throws

在这里插入图片描述

try-catch-finally

在这里插入图片描述在这里插入图片描述在这里插入图片描述

多重catch
  • 一旦某个catch捕获到匹配的异常类型,将进入异常处理代码。一经处理结束,就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会
  • 对于有多个catch子句的异常程序而言,应该尽量将捕获底层异常类的catch子句放在前面,同时尽量将捕获相对高层的异常类的catch子句放在后面。否则,捕获底层异常类的catch子句将可能会被屏蔽

引发多种类型的导常

-排列 catch 语句的顺序:先子类后父类
-发生异常时按顺序逐个匹配
-只执行第一个与异常类型匹配的catch

实际应用中的经验与总结
  • 处理运行时异常时,采用逻辑去合理规避同时辅助try-catch处理
  • 在多重catch块后面,可以加一个catch(Exception)来处理可能会被遗漏的异常
  • 对于不确定的代码,也可以加上try-catch,处理潜在的异常
  • 尽量去处理异常,切忌只是简单的调用prinsStackTrace()去打印输出
  • 具体如何处理异常,要根据不同的业多需求和异常类型去决定
  • 尽量添加finally语句块去释放占用的资源
package com.sh.test;
import java.util.InputMismatchException;
import java.util.Scanner;

public class TryDemoOne {

	public static void main(String[] args) {
	/*	// 要求:定义两个整数,输出两数之商
		
		int one=12;
		int two=2;
		System.out.println("one和two的商是:"+ (one/two));
    */
		
		// 要求:定义两个整数,接受用户的键盘输入,输出两数之商
		Scanner input=new Scanner(System.in);
		System.out.println("=====运算开始=====");
		try{
			System.out.print("请输入第一个整数:");
			int one=input.nextInt();
			System.out.print("请输入第二个整数:");
			int two=input.nextInt();
			System.out.println("one和two的商是:"+ (one/two));
		}catch(ArithmeticException e){
			System.exit(1);//终止程序运行
			System.out.println("除数不允许为零");
			e.printStackTrace();
		}catch(InputMismatchException e){
			System.out.println("请输入整数");
			e.printStackTrace();
    	}catch(Exception e){
			System.out.println("出错啦~~");
			e.printStackTrace();
		}finally{
			System.out.println("=====运算结束=====");
		}
	}
}

return关键字在异常中的用法

package com.sh.test;
import java.util.InputMismatchException;
import java.util.Scanner;

public class TryDemoTwo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int result=test();
		System.out.println("one和two的商是:"+ result);
		
	}

	public static int test(){
		Scanner input=new Scanner(System.in);
		System.out.println("=====运算开始=====");
		try{
			System.out.print("请输入第一个整数:");
			int one=input.nextInt();
			System.out.print("请输入第二个整数:");
			int two=input.nextInt();
			return one/two;
		}catch(ArithmeticException e){
			System.out.println("除数不允许为零");
			return 0;
		}finally{
			System.out.println("=====运算结束=====");
		//	return -100000;
		}
	}
}

throw & throws
  • 可以通过throws声明将要抛出何种类型的异常,通过throw将产生的异常抛出
throws
  • 如果一个方法可能会出现异常,但没有能力处理这种异常,可以在方法声明处用throws子句来声明抛出异常
  • 例如:汽车在运行时可能会出现故障,汽车本身没办法处理这个故障, |那就让开车的人来处理

在这里插入图片描述

package com.sh.test;
import java.util.InputMismatchException;
import java.util.Scanner;

public class TryDemoThree {

	public static void main(String[] args) throws Exception {
//		try {
//			// TODO Auto-generated method stub
//			int result = test();
//			System.out.println("one和two的商是:" + result);
//		} catch (ArithmeticException e) {
//			System.out.println("除数不允许为零");
//			e.printStackTrace();
//		}catch(InputMismatchException e){
//			System.out.println("请输入整数");
//			e.printStackTrace();
//	}
		try{
			int result = test();
			System.out.println("one和two的商是:" + result);
		}catch(ArithmeticException e){
			
		}catch(InputMismatchException e){
			
		}catch(Exception e){
			
		}
		int result2=test();
	}

	/*通过throws抛出异常时,针对可能出现的多种异常情况,解决方案:
	 * 1、throws后面接多个异常类型,中间用逗号分隔
	 * 2、throws后面接Exception
	 * */
	/**
	 * 测试接收数据相除结果的方法
	 * @return 两个接收数据的商
	 * @throws ArithmeticException
	 * @throws InputMismatchException
	 */
//	public static int test() throws ArithmeticException,InputMismatchException{
//		Scanner input = new Scanner(System.in);
//		System.out.println("=====运算开始=====");
//		System.out.print("请输入第一个整数:");
//		int one = input.nextInt();
//		System.out.print("请输入第二个整数:");
//		int two = input.nextInt();
//		System.out.println("=====运算结束=====");
//		return one / two;
//	}

	public static int test() throws Exception{
		Scanner input = new Scanner(System.in);
		System.out.println("=====运算开始=====");
		System.out.print("请输入第一个整数:");
		int one = input.nextInt();
		System.out.print("请输入第二个整数:");
		int two = input.nextInt();
		System.out.println("=====运算结束=====");
		return one / two;
	}
}

throws使用规则
  • 如果是不可查异常( unchecked exception ),即Error、RuntimeException或它们的子类,那么可以不使用throws关键字来声明要抛出的异常,编译仍能顺利通过,但在运行时会被系统抛出
  • 如果一个方法中可能出现可查异常,要么用try-catch语句捕获,要么用throws子句声明将它抛出,否则会导致编译错误
  • 当抛出了异常,则该方法的调用者必须处理或者重新抛出该异常
  • 当子类重写父类抛出异常的方法时,声明的异常必须是父类方法所声明异常的同类或子类
throw
  • throw用来抛出一个异常
  • 例如: throw new IOException();
  • throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象
  • 例如:throw new String(出错啦");是错误的
自定义异常
  • 使用Java内置的异常类可以描述在编程时出现的大部分异常情况
  • 也可以通过自定义异常描述特定业务产生的异常类型
  • 所谓自定义异常,就是定义一个类,去继承Throwable类或者它的子类

自定义异常类

package com.sh.test;

public class HotelAgeException extends Exception {
	public HotelAgeException(){
		super("18岁以下,80岁以上的住客必须由亲友陪同");
	}
}

class SubException extends HotelAgeException{
	
}
package com.imooc.test;

import java.util.Scanner;

public class TryDemoFour {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			testAge();
		} catch (HotelAgeException e) {
			System.out.println(e.getMessage());
			System.out.println("酒店前台工作人员不允许办理入住登记");
		}catch(Exception e){
			e.printStackTrace();
		}
	}

	/*
	 * throw抛出异常对象的处理方案:
	 * 1、通过try..catch包含throw语句--自己抛自己处理
	 * 2、通过throws在方法声明出抛出异常类型--谁调用谁处理--调用者可以自己处理,也可以继续上抛
	 *    此时可以抛出与throw对象相同的类型或者其父类
	 */
	// 描述酒店的入住规则:限定年龄,18岁以下,80岁以上的住客必须由亲友陪同
	/*public static void testAge() {

		try {
			System.out.println("请输入年龄:");
			Scanner input = new Scanner(System.in);
			int age = input.nextInt();
			if (age < 18 || age > 80) {
				throw new Exception("18岁以下,80岁以上的住客必须由亲友陪同");
			} else {
				System.out.println("欢迎入住本酒店");
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}*/
	public static void testAge() throws HotelAgeException {
		System.out.println("请输入年龄:");
		Scanner input = new Scanner(System.in);
		int age = input.nextInt();
		if (age < 18 || age > 80) {
			//throw new ArithmeticException();
			//throw new Exception("18岁以下,80岁以上的住客必须由亲友陪同");
			throw new HotelAgeException();
		} else {
			System.out.println("欢迎入住本酒店");
		}
	}
}

异常链

  • 有时候我们会捕获一个异常后再抛出另一个异常
  • 顾名思义就是:将异常发生的原因一个传一个串起来,即把底层的异常信息传给上层,这样逐层抛出
package com.sh.test;
public class TryDemoFive {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			testThree();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static void testOne() throws HotelAgeException {
		throw new HotelAgeException();
	}

	public static void testTwo() throws Exception {
		try {
			testOne();
		} catch (HotelAgeException e) {
			throw new Exception("我是新产生的异常1",e);
		}
	}

	public static void testThree() throws Exception {
		try {
			testTwo();
		} catch (Exception e) {
			Exception e1=new Exception("我是新产生的异常2");
			e1.initCause(e);
			throw e1;
//			throw new Exception("我是新产生的异常2",e);
		}
	}
}

总结

  • 异常
  • 异常分类
  • 异常处理(抛出异常,捕获异常)
  • 异常处理 try-catch-finally
  • 自定义异常
  • 异常链
  • 常见异常类型
    在这里插入图片描述
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值