JAVA基础学习笔记(10)：异常

1 异常

1.1 异常的概念

在Java语言中，将程序执行中发生的不正常情况称为“异常”。 (开发过程中的语法错误和逻辑错误不是异常)

1.2 异常的分类

java执行过程中的异常事件可分为两类：Error和Exception

1.2.1 Error

Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError和OOM。一般不编写针对性的代码进行处理。

public class ErrorTest {
	public static void main(String []args) {
		//1.栈溢出：java.lang.StackOverflowError
//		main(args);
		//2.堆溢出：java.lang.OutOfMemoryError
		Integer[] arr = new Integer[1024*1024*1024];
	}
}

1.2.2 Exception

其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：空指针访问、试图读取不存在的文件、网络连接中断、数组角标越界。
一般只把此类异常称为我们所要解决的异常

1.3 异常的体系结构

在这里插入图片描述
编译时异常（checked）：是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。
运行时异常（unchecked）：是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常。

1.4 常见的异常举例

import java.util.Date;
import java.util.Scanner;
import org.junit.jupiter.api.Test;

public class ExceptionTest {
	
	//**********************常见的运行时异常*****************************/
	//ArithmeticException：数学计算异常
	@Test
	public void test6() {
		int a = 10;
		int b = 0;
		System.out.println(a/b);
	}
	
	//InputMismatchException：输入不匹配异常
	@Test
	public void test5() {
		Scanner scanner = new Scanner(System.in);
		int score = scanner.nextInt();
		System.out.println(score);
		scanner.close();
	}
	
	//NumberFormatException：数据格式异常
	@Test
	public void test4() {
		String str = "123";
		str = "abc";
		int num = Integer.parseInt(str);
	}
	
	
	//ClassCastException：类型转换异常
	@Test
	public void test3(){
		Object obj = new Date();
		String str = (String)obj;
	}
	
	//ArrayIndexOutOfBoundsException:数组越界异常
	@Test 
	public void test2(){
//		ArrayIndexOutOfBoundsException
//		int[] arr = new int[10];
//		System.out.println(arr[10]);
		//StringIndexOutOfBoundsException
		String str = "abc";
		System.out.println(str.charAt(3));
	}
	
	
	//NullPointerException：空指针异常
	@Test
	public void test1() {
//		int[] arr = null;
//		System.out.println(arr[10]);
		
		String str = null;
		System.out.println(str.charAt(0));
	}
}

1.5 异常的处理方式

抓抛模型：Java程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出 (throw)异常。一旦抛出则之后的代码无法运行。
抓可以看作是对异常的处理：有try-catch-finally和throws两种方式

1.5.1 try-catch-finally处理方式

基本结构如下所示:

try{
	//可能出现异常的代码
}catch(异常类型1 变量名1){
	//处理异常的方式1
}catch(异常类型2 变量名2){
	//处理异常的方式2
}catch(异常类型3 变量名3){
	//处理异常的方式3
}
......
finally{
	//一定会执行的代码
}

使用的一些说明：
1.finally是可选的。
2.使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配
3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（在没有写finally的情况）。继续执行其后的代码
4. catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错
5. 常用的异常对象处理的方式： ① String getMessage() ② printStackTrace()
6. 在try结构中声明的变量，再出了try结构以后，就不能再被调用
7. try-catch-finally结构可以嵌套

public class ExceptionTest1 {
	@Test
	public void test1() {
		String str = "123";
		str = "abc";
		try {
			int num = Integer.parseInt(str);
		}catch(NumberFormatException e) {
			//System.out.println("出现了数值转换异常，不要着急！！");
			//常见的异常解决方法
			//解决方法1：
			//System.out.println(e.getMessage());
			//解决方法2：
			e.printStackTrace();		
		}catch(NullPointerException e) {
			System.out.println("出现了空指针异常，不要着急！！");
		}catch(Exception e) {//Exception是上面几个的父类，所以不可以放到第一个，那样的话下面两个异常不可达
			System.out.println("出现了异常，不要着急");
		}
	}

}

有关finally使用的一些说明：
1.finally是可选的
2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch中有return语句等情况。
3.像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的释放。此时的资源释放，就需要声明在finally中。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import org.junit.jupiter.api.Test;

public class FinallyTest {
	
	@Test 
	public void test3() {
		FileInputStream fis = null;
		try {
			File file = new File("hello.txt");
			fis = new FileInputStream(file);
			
			int data = fis.read();
			while(data != 1) {
				System.out.print((char)data);
				data = fis.read();
			}	
		}catch(FileNotFoundException e) {
			e.printStackTrace();
		}catch(IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if(fis != null) {
					fis.close();
				}
			}catch(IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	@Test
	public void test2() {
		int num = method();
		System.out.println(num);
	}
	
	public int method() {
		try {
			int[] arr = new int[10];
			System.out.println(arr[10]);
			return 0;
		}catch(ArrayIndexOutOfBoundsException e) {
			e.printStackTrace();
			return 1;
		}catch(Exception e) {
			e.printStackTrace();
			return 2;
		}finally {
			System.out.println("我一定被执行");
//			return 3;   //如果打开这行，返回值一定为3
		}
	}
	
	@Test
	public void test1() {
		try {
			int a = 10;
			int b = 0;
			System.out.println(a/b);
		}catch(ArithmeticException e) {
			//e.printStackTrace();
			int[] arr = new int[10];
			System.out.println(arr[10]);
		}catch(Exception e) {
			e.printStackTrace();
		}
		//System.out.println("lalalalal");如果这行开启，则不会输出
		finally {
			System.out.println("lalalalala");
		}			
	}
}

1.5.1.1 关于异常两点体会

1.使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
2.开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。针对于编译时异常，我们说一定要考虑异常的处理。

1.5.2 throws处理方式

1."throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码，就不再执行！
2.try-catch-finally:真正的将异常给处理掉了。throws的方式只是将异常抛给了方法的调用者。并没有真正将异常处理掉。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ThrowsTest {
	public static void main(String[] args) {
		try {
			method2();
		}catch(IOException e) {
			e.printStackTrace();
		}
		method3();
	}
	
	public static void method3() {
		try {
			method2();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public static void method2() throws IOException {
		method1();
	}
	
	public static void method1() throws FileNotFoundException,IOException {
		File file = new File("hello.txt");
		FileInputStream fis = new FileInputStream(file);
		
		int data = fis.read();
		while(data != 1) {
			System.out.print((char)data);
			data = fis.read();
		}	
		fis.close();
	}
}

1.5.3 try-catch-finally和throws选择

1.如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理。
2.执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。

1.6 重写父类异常方法的抛出规则

子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型。

import java.io.FileNotFoundException;
import java.io.IOException;
//子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
public class OverrideTest {
	
	public static void main(String[] args) {
		OverrideTest test = new OverrideTest();
		test.display(new SubClass());
	}
	
	public void display(SupClass s){
		try {
			s.method();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

class SupClass{
	public void method() throws IOException{
		
	}
}

class SubClass extends SupClass{
	public void method() throws FileNotFoundException{
		
	}
}

1.7 手动抛出异常

1.一般只抛出RuntimeException或者Exception这两种异常。
2.注意throw是手动抛出异常的关键字，throws是跟在函数声明之后用来抛出异常类型的关键字。

public class StudentTest {
	public static void main(String[] args) {
		Student s = new Student();
		try {
			s.regist(-1000);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			//e.printStackTrace();
			System.out.println(e.getMessage());
		}
		//System.out.println(s.toString());
	}

}


class Student{
	
	private int id;
	
	public void regist(int id) throws Exception{
		if(id > 0) {
			this.id = id;
		}else {
			//System.out.println("您输入的数据非法!!!");
			//手动抛出异常对象(只抛出这两种异常)
			//throw new RuntimeException("您输入的数据非法！！");
			throw new Exception("您输入的数据非法！！");
		}
	}

	@Override
	public String toString() {
		return "Studnet [id=" + id + "]";
	}
}

1.8 自定义异常类

1.继承于现有的异常结构：RuntimeException 、Exception
2.提供全局常量：serialVersionUID
3.提供重载的构造器

package day16.java1;

public class MyException extends Exception {
	
	 static final long serialVersionUID = -3387516993124222948L;
	 
	 public MyException() {
		 super();
	 }
	 
	 public MyException(String msg){
		 super(msg);
	 }
}

1.9 总结

在这里插入图片描述

本节练习

ex1

在这里插入图片描述
注意从控制台输入的方法，在eclipse中右键->run as->run configurations->Arguments中输入想要输入的参数。
EcDef.java:

public class EcDef extends RuntimeException{
	static final long serialVersionUID = -7033897190745766939L;
	
	public EcDef() {
		super();
	}
	
	public EcDef(String msg) {
		super(msg);
	}
}

EcmDef.java:

public class EcmDe {
	public static void main(String[] args) {
		try {
			int i = Integer.parseInt(args[0]);
			int j = Integer.parseInt(args[1]);
		    int result = ecm(i,j);
		    System.out.println(result);
		}catch(NumberFormatException e){
			System.out.println("数据类型不一致！");
		}catch(ArrayIndexOutOfBoundsException e) {
			System.out.println("缺少命令行参数！");
		}catch(ArithmeticException e) {
			System.out.println("分母不能为0！");
		}catch(EcDef e) {
			System.out.println(e.getMessage());
		}
	}
	
	public static  int ecm(int i, int j) throws EcDef{
		if(i<0 || j<0) {
			throw new EcDef("不能输入负数");
		}
		if(j == 0) {
			throw new ArithmeticException();
		}
		return  i /j;
	}
}

参考资料：
[1]尚硅谷宋康红java基础教程