Java有关异常的超详细笔记

Java_ 异常

引言：
     本文主要写了Java有关异常的部分，从异常的分类开始介绍包括异常的产生、传递、两种常用的处理方式、自定义异常以及异常中面试题；

---

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. 异常的产生

1. 自动抛出异常：当程序在运行时遇到不符合规范的代码或结果时，会产生异常；

2. 手动抛出异常：语法:throw new 异常类型（”实际参数”）；

3. 产生异常结果：相当于遇到了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里面代码越少越好，防止加载过多代码冗余

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相关的结构

1. try{}catch{}

2. try{}catch{}catch{}

3. try{}catch{}finally{}

4. try{}catch{}catch{}finally{}

5. 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；