Java有关异常的超详细笔记
Java_ 异常
引言：
本文主要写了Java有关异常的部分，从异常的分类开始介绍包括异常的产生、传递、两种常用的处理方式、自定义异常以及异常中面试题；
文章目录
- Java_ 异常
- 1. 异常概述
- 1.1 异常的分类
- 1.2 Error 异常
- 1.3 Exception 异常
- 2. 异常的产生
- 3. 异常的传递
- 4. Throwable 类
- 5. 异常的处理方案
- 5.1 try...catch...finally... 格式
- 5.1.1 try...catch...
- 5.1.2 多重Catch
- 5.1.3 try...catch...finally
- 5.1.4 JDK1.7之后
- 4.1.5 try...catch... 的执行原理
- 4.1.6 try...catch相关的结构
- 5.2 throws抛出异常
- 6. 自定义异常
- 7. 异常的注意事项
- 8. 异常中的面试题
- 8.1 编译时期异常和运行时期异常的区别
- 8.2 关于throws和throw的区别
- 8.3 final,finally,finalize之间的区别
- 8.4 在try...catch...finally中,如果catch语句中有return语句的,finally一定会执行吗?在return之前还是之后？
1. 异常概述
异常就是Java程序在运行过程中出现的特殊情况；
异常处理的必要性：
- 任何程序都可能存在大量的未知问题、错误；如果不对这些问题进行处理，可能导致程序的中断造成一定程度上的损失；
1.1 异常的分类
Throwable：可抛出的异常，一切错误异常的父类，在java.Lang包中。
只有当对象是此类或者子类之一的实例时，才能通过语句抛出。
Error：JVM、硬件、执行逻辑错误，一般不能手动处理,程序出现严重的问题(其他方式避免这种严重问题)
Exception：程序在运行和配置中产生的问题，开发者可以处理,Exception下面的所有异常都是平级关系
- RuntimeException：运行时异常，代码不够严谨会存在安全隐患，可处理也可不处理，不处理就是JVM帮我们处理,打印堆栈跟踪信息；Eg：NullPointerException：空指针异常
- CheckedException：受查异常，编译时期异常只要不是运行时发生的异常都属于编译时期异常，必须处理。Eg：parseException :解析异常
如果程序出现了问题，我们没有做任何处理，最终jvm会做出默认的处理，把异常的名称，原因及出现的问题等信息输出在控制台，同时结束程序；
public static void main(String[] args) {
int a = 10;
int b = 0;
System.out.println(a/b);//java.lang.ArithmeticException: / by zero 除数不能为0 属于算数异常
System.out.println("over");
}
- 上述代码由于没有做任何处理，JVM将此异常打包成一个异常对象，抛给了main函数，main函数自己解决不了因此交给JVM，JVM在控制台输出java.lang.ArithmeticException: / by zero，异常信息并停止程序的执行；
1.2 Error 异常
public static void main(String[] args) {
m1();
}
//程序当中--->error--->致命的（）
public static void m1() {
int a = 20;
int b = 30;
m1();
}
- Exception in thread “main” java.lang.StackOverflowError：栈内存溢出(不能手动处理也就是不能通过另外一段代码解决当前错误);
1.3 Exception 异常
public static void main(String[] args) {
m6();
//程序运行过程中的异常
}
// java.lang.ClassCastException类型转换异常
public static void m1(){
Object o = new Integer(2);
Scanner sc = (Scanner)o;
}
// java.lang.ArithmeticException算数异常
public static void m2(){
System.out.println(10/0);
}
//java.lang.ArrayIndexOutOfBoundsException数组下标越界异常
public static void m3() {
int[] nums = new int[1];
System.out.println(nums[1]);
}
// java.lang.StringIndexOutOfBoundsException字符串下标越界
public static void m4() {
String s = "wer";
System.out.println(s.charAt(4));
}
// java.util.InputMismatchException输入错误异常
public static void m5() {
Scanner sc = new Scanner(System.in);
System.out.println("输入数字：");
int n = sc.nextInt();
}
// java.lang.NullPointerException空指针异常
public static void m6() {
Object o = null;
o.hashCode();
}
2. 异常的产生
-
自动抛出异常：当程序在运行时遇到不符合规范的代码或结果时，会产生异常；
-
手动抛出异常：语法:throw new 异常类型（”实际参数”）；
-
产生异常结果：相当于遇到了return语句，导致程序因异常而终止；
public class ThrowException {
public static void main(String[] args) {
Student stu = new Student();
stu.setAge(145);
System.out.println("年龄时：" +stu.getAge());
}
}
class Student{
private int age;
public int getAge() {
return this.age;
}
public void setAge(int age) {
if(age > 0 && age <125){
this.age = age;
}else{
//创建异常，单独存在就意味着仅是个对象
RuntimeException re = new RuntimeException();
//结合throw关键字，抛出异常
throw re;
//throw new RuntimeException();
}
}
}
- 在上述程序因为年龄输入不符合规范所以抛出异常，当产生异常相当于遇到了return语句使程序结束，在抛出异常时要结合throws关键字，可整合为 “throw new RuntimeException”；
3. 异常的传递
按照方法的调用链反向传递，如果始终没有处理异常，最终会由JVM进行默认异常处理（打印堆栈跟踪信息）
- 受查异常：throws声明异常，修饰在方法参数列表的后面（代码后飘红线）。
- 运行时异常：可处理也可不处理，无需声明异常。
public class TestTransferException {
//打印堆栈跟踪信息
public static void main(String[] args) throws Exception {
System.out.println("main - start");
m1(10);
System.out.println("main - end");
}
public static void m1(int n) throws Exception{
System.out.println("m1 - start");
m2(n);
System.out.println("m1 - end");
}
public static void m2(int n) throws Exception{
System.out.println("m2 - start");
m3(n);
System.out.println("m2 - end");
}
//声明该方法可能存在受查异常
public static void m3(int n) throws Exception{
System.out.println("m3 - start");
if(n % 2 ==0){
throw new Exception();
}
System.out.println("m3 - end");
}
}
- 传入奇数程序正常执行，当传入偶数在m3方法中抛出异常，属于受查异常，m3通过抛出异常向上面m2方法声明可能存在异常，m2传给m1直到有main方法传给JVM打印堆栈跟踪信息，按照方法的调用链反向传递；
- 运行时异常对程序没有影响，可以不声明；
4. Throwable 类
常用方法：
- public String getMessage()：返回该错误的详细信息的字符串
- public String toString()：返回一个对这个异常的简短描述
- public void printStackTrace()：包含了getMessage()以及toString()，追踪到自己开发程序的某个行代码中以及涉及Java源码
public static void main(String[] args) {
//给定一个字符串日期文本格式
String s = "2020-6-25" ;
//创建SimpleDateFormat对象
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd "); //JVM异常对象new ParseException()
Date d = sdf.parse(s) ;
}catch(ParseException e){ //判断是否匹配,成功执行catch中语句(匹配成功)
//返回该错误的详细信息的字符串
String msg = e.getMessage() ;
System.out.println(msg);//Unparseable date: "2020-6-25"
//返回一个对这个异常的简短描述
String strMsg = e.toString() ;
System.out.println(strMsg);//java.text.ParseException: Unparseable date: "2020-6-25"
//打印到标准错误流这个异常和回溯
e.printStackTrace();
}
System.out.println("End");
}
- 创建SimpleDataFormat对象时故意多加一空格
5. 异常的处理方案
异常的处理：
- try{}catch{}finally{}
- throws
5.1 try…catch…finally… 格式
5.1.1 try…catch…
try{
可能出现异常的代码；
}catch(异常类名 变量名){
异常处理相关代码
}
public static void main(String[] args) {
int a = 10;
int b = 0;
//第一种try...catch...处理异常
try{
System.out.println(a/b);
}catch(ArithmeticException e){
System.out.println("除数不能为0");//自定义处理
//e.printStackTrace();//jvm处理
System.out.println(e.getMessage());//获取异常的原因
}
System.out.println("over");
}
- 注：
- catch里面:处理异常,一旦出问题了,将异常信息打印控制台上
- 自定义处理
- JVM打印堆栈跟踪信息
- 通过getMessage获取异常的原因
- try里面代码越少越好，防止加载过多代码冗余
- catch里面:处理异常,一旦出问题了,将异常信息打印控制台上
5.1.2 多重Catch
try{
可能出现异常的代码；
}catch(异常类名1 变量名1){
异常处理相关代码
}catch(异常类名2 变量名2){
异常处理相关代码
}
…
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
try {
System.out.println("请输入一个被除数");
int num1 = sc.nextInt();
System.out.println("请输入一个除数");
int num2 = sc.nextInt();
int result = num1 / num2;
System.out.println(result);
}catch(ArithmeticException e) {
System.out.println("除数不能为0");
}catch(InputMismatchException e) {
System.out.println("请输入正确的整数");
}catch(Exception e) {
System.out.println("出现未知错误");
}
System.out.println("程序结束");
}
}
- 多重catch中如果有多个异常,并且存在异常父子关系的话,异常父类一定是在末尾,不能放在类的前面,遵循从子（小）到父（大）的顺序，父类异常在最后
5.1.3 try…catch…finally
try{
可能出现异常的代码；
}catch(异常类名 变量名){
异常处理相关代码
}finally{
无论是否出现异常，都需要执行的代码结构，常用于释放资源
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
try{
System.out.println("输入一个被除数：");
int i1 = sc.nextInt();
System.out.println("输入一个除数：");
int i2 = sc.nextInt();
int result = i1 / i2;
System.out.println("结果为：" + result);
}catch(ArithmeticException e){
System.out.println("除数不能为0");
}
catch(InputMismatchException e){
System.out.println("输入错误");
}catch(Exception e){
System.out.println("出现未知异常");
}finally{
System.out.println("End");
}
}
5.1.4 JDK1.7之后
JDK7以后出现一种格式针对多个异常的处理
try{
可能出现问题的代码
}catch(异常类名1 | 异常类名2 | … 变量名){
处理异常
}
public static void main(String[] args) {
int a = 10 ;
int b = 0 ;
int arr[] = {11,22,33} ;
try {
System.out.println(arr[3]);
System.out.println(a/b);
}catch(ArithmeticException | ArrayIndexOutOfBoundsException e) {
System.out.println("除数不能为0");
System.out.println("数组角标越界了");
}
}
- 注：只能针对异常类名是同一种异常类型
4.1.5 try…catch… 的执行原理
当前程序进入到try语句中,一旦出问题了,就会通过JVM 虚拟机产生一个异常对象 new XXXException()内存中,然后进入到catch语句中判断JVM 产生的异常的实例是否是和catch语句中的异常类一样,如果一样执行catch语句中的代码；
4.1.6 try…catch相关的结构
-
try{}catch{}
-
try{}catch{}catch{}
-
try{}catch{}finally{}
-
try{}catch{}catch{}finally{}
-
try{}finally{}
5.2 throws抛出异常
throws:抛出 在方法声明上表示出现异常的可能性
- 编译时期异常,如果在方法抛出异常了,调用者必须处理
- 运行时期异常调用者不需要处理
详见在第三个板块异常的传递部分
6. 自定义异常
需继承自Exception或Exception的子类，常用RuntimeException。
必要提供的构造方法：
- 无参构造方法
- String message参数的构造方法
public class TestDefinedException {
public static void main(String[] args) {
Student stu = new Student();
try {
stu.setAge(250);//是可能出现异常的代码
}catch(Exception e) {
System.err.println(e.getMessage());//只获得报错的原因
}
try {
stu.setSex("nan");//受查异常编译时就报错要处理
}catch(SexMismatchException se) {//捕获相应的类型
System.err.println(se.getMessage());
}catch(Exception e ) {
e.printStackTrace();
}
}
}
//受查异常：需要声明出去
class SexMismatchException extends Exception{
public SexMismatchException() {}
public SexMismatchException(String message) {
super(message);
}
}
//运行时异常
class AgeInputException extends RuntimeException{
public AgeInputException() {}//创建无异常原因信息的异常对象
public AgeInputException(String message) {//编写异常原因信息
super(message); //为message属性赋值。
}
}
//自定义异常
class Student{
private int age;//年龄
private String sex;//性别 男 女
public void setSex(String sex) throws SexMismatchException {
if(sex.equals("男") || sex.equals("女")) {
this.sex = sex;
}else {
//在用户输入一个性别后提醒。
throw new SexMismatchException("性别输入的值为:“男”或“女”");
}
}
public String getSex() {
return this.sex;
}
public int getAge() {
return this.age;
}
public void setAge(int age){
if(age > 0 && age < 123) {
this.age = age;
}else {
throw new AgeInputException("年龄的赋值应该在0岁到123岁之间"); //抛运行时异常的父类
}
}
}
7. 异常的注意事项
- 在继承关系中，如果父类中方法抛出了异常了，那么子类在重写父类该方法的时候，也必须抛出该异常，异常要么跟父类的方法一样，要么父类方法异常类的子类
- 如果父类中的方法抛出了多个异常,那么子类重写父类方法时候,抛出的异常一定是父类的异常或他的异常类的子类
- 父类中的方法如果没有抛出异常,那么子类在重写父类方法的时候,不能抛出(throws)异常只能try…catch…捕获异常
class Fu{
public void show() throws Exception{}
public void method(){}
}
class Zi extends Fu{
public void show() throws ArithmeticException{}
public void method(){
String dataStr = "1200-12-07";
//创建SimpleDataFormat解析日期文本格式
try{
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse(dataStr) ;
System.out.println(date);
}catch (ParseException e) {
e.printStackTrace();{
}
}
}
}
8. 异常中的面试题
8.1 编译时期异常和运行时期异常的区别
编译时期异常:开发者必须处理的，编译通过不了；比如：NullPointerException:空指针(防止对象为null)
运行时期异常:代码不严谨,无需显示处理
public static void main(String[] args) {
method() ;
}
private static void method() {
//String:日期文本格式
String s = "2020-6-18" ;
//parse(String s) throws ParseException:解析 编译时期异常
Date date = null ;
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
date = sdf.parse(s) ;
//直接使用异常对象名.printStackTrace()
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println(date);
}
- 编译时异常必须处理，通过try…catch
public static void main(String[] args) {
//运行时期异常:开发者不需要显示处理
int a = 10 ;
int b = 0 ;
if(b!=0) {
System.out.println(a/b);
}else {
System.out.println("除数不能0");
}
}
- 运行时异常可以不处理直接交给JVM虚拟机处理，也可以加入逻辑判断处理；
8.2 关于throws和throw的区别
throws:
- 抛出在方法声明上,方法后面跟的是异常类名而且可以多个中间用逗号隔开
- throws:表示抛出异常的可能性(可能会出现异常,可能不出现)
- throws抛出的异常,交给调用者处理
throw：
- 抛出在方法体中,方法体中跟的是异常对象名 new XXxException()
- throw:表单抛出异常的肯定性执行这段代码一定会出现异常
- throw抛出的异常,交给了方法体中语句进行处理
- throw 后面只能跟一个异常对象，一般时具体的异常对象
public static void main(String[] args) throws Exception {
method() ;
method2() ;
}
private static void method2() {
int a = 10 ;
int b = 0 ;
if(b==0) {
throw new ArithmeticException(); // 交给JVM将异常信息输出控制台上
}else {
System.out.println(a/b);
}
}
private static void method() throws Exception {
int a = 10 ;
int b = 0 ;
if(b==0) {
throw new Exception() ; //不是明确的异常对象
}else {
System.out.println(a/b);
}
}
8.3 final,finally,finalize之间的区别
final：
- 状态修饰符
- 修饰类,该类不能继承
- 修饰成员方法,该方法不能被重写
- 修饰成员变量,该变量—常量
finalize：
- 回收操作，跟Gc有关系垃圾回收器开启的时候回收没有更多引用的对象
finally：
- 是Java异常处理的一部分，只要不在执行finally语句前退出JVM那么其中的代码一定会执行，该部分主要去释放资源，如：流的资源，JDBC的数据库的链接对象
8.4 在try…catch…finally中,如果catch语句中有return语句的,finally一定会执行吗?在return之前还是之后？
- 是Java异常处理的一部分，只要不在执行finally语句前退出JVM那么其中的代码一定会执行，该部分主要去释放资源，如：流的资源，JDBC的数据库的链接对象
public static void main(String[] args){
System.out.println(getInt());
}
private static int getInt(){
int a = 10;
int b = 0;
try{
a = 20;
System.out.println(a/b);
}catch(ArithmeticException e){
a = 30;
return a;//30
}finally{
a = 40;
}
return a;
}
}
- try…catch…finally中，如果catch语句中有return语句的，finally一定会执行且是在return之前执行；
- 虽然走了finally但是没有返回值，所以输出30，在16行后面加上return a;那么返回的就是40；