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
- 自定义异常
- 异常链
- 常见异常类型