常见异常以及异常处理
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
目录
文章目录
前言
一、Throwable为顶层父类。
二、初识异常与常见异常
1.初识异常
2.常见异常
三、异常处理的处理机制
异常处理机制一：try-catch-finally
异常处理机制二：throws -------> 抛出给调用方法的人
四、手动抛出异常：throw------>自己生成一个异常然后将其抛出
总结
前言
提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。
提示：以下是本篇文章正文内容，下面案例可供参考
一、Throwable为顶层父类。
两个子类：
Error和Exception的区别:
Error和Exception都有一个共同的根类是Throwable类。
Error是系统中的错误，程序员是不能改变的和处理的，一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。因此我们编写程序时不需要关心这类错误。
Exception，也就是我们经常见到的一些异常情况，表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。
检查异常
What:什么是检查异常(checked exception)?---------->编译时异常
就是编译器要求你必须处置的异常。不知道你编程的时候有没有遇到过，你写的某段代码，编译器要求你必须要对这段代码try...catch，或者throws exception，如果你遇见过，没错，这就是检查异常，也就是说，你代码还没运行呢，编译器就会检查你的代码，会不会出现异常，要求你对可能出现的异常必须做出相应的处理。
javac强制要求程序员为这样的异常做预备处理工作（使用try...catch...finally或者throws）。在方法中要么用try-catch语句捕获它并处理，要么用throws子句声明抛出它，否则编译不会通过。这样的异常一般是由程序的运行环境导致的。因为程序可能被运行在各种未知的环境下，而程序员无法干预用户如何使用他编写的程序，于是程序员就应该为这样的异常时刻准备着。如SQLException , IOException,ClassNotFoundException 等。
比如:我们调用日期格式化类解析字符串的时候;
How:怎样处理检查异常（checked exception）?
1、继续抛出，消极的方法，一直可以抛到java虚拟机来处理，就是通过throws Exception抛出。
2、用try...catch捕获
注意，对于检查的异常必须处理，或者必须捕获或者必须抛出
Where:检查异常有哪些呢？
除了RuntimeException与其子类，以及错误（Error），其他的都是检查异常（绝对的大家族）。
非检查异常
What:什么是非检查异常（unchecked exceptions）？---------->运行时异常
编译器不要求强制处置的异常，虽然你有可能出现错误，但是编译器不会在编译的时候检查，没必要，也不可能。
javac在编译时，不会提示和发现这样的异常，不要求在程序处理这些异常。所以如果愿意，我们可以编写代码处理（使用try...catch...finally）这样的异常，也可以不处理。
对于这些异常，我们应该修正代码，而不是去通过异常处理器处理。这样的异常发生的原因多半是代码写的有问题。如除0错误ArithmeticException，错误的强制类型转换错误ClassCastException，数组索引越界ArrayIndexOutOfBoundsException，使用了空对象NullPointerException等等。
How:对非检查的异常(unchecked exception )怎样处理?
1、用try...catch捕获
2、继续抛出
3、不处理
4、通过代码处理
一般我们是通过代码处理的，因为你很难判断会出什么问题，而且有些异常你也无法运行时处理，比如空指针，需要人手动的去查找。
而且，捕捉异常并处理的代价远远大于直接抛出。
Why:为什么有非检查异常？
你想想非检查异常都有哪些？NullPointerException，IndexOutOfBoundsException，VirtualMachineError等，这些异常你编译的时候检查吗？再说了，明明可以运行时检查，都在编译的时候检查，你写的代码还能看吗？而且有些异常只能在运行时才能检查出来，比如空指针，堆溢出等。
二、初识异常与常见异常
1.初识异常
下面的代码会演示2个异常类型：ArithmeticException 和 InputMismatchException。
前者由于整数除0引发，后者是输入的数据不能被转换为int类型引发。
import java.util.Scanner;
public class AllDemo {
public static void main(String[] args) {
System.out.println("----欢迎使用命令行除法计算器----");
CMDCalculate();
}
public static void CMDCalculate() {
Scanner scan = new Scanner(System.in);
int num1 = scan.nextInt();
int num2 = scan.nextInt();
int result = devide(num1, num2);
System.out.println("result:" + result);
scan.close();
}
public static int devide(int num1, int num2) {
return num1 / num2;
}
}
/*****************************************
----欢迎使用命令行除法计算器----
2
0
Exception in thread "main" java.lang.ArithmeticException: / by zero
at AllDemo.devide(AllDemo.java:19)
at AllDemo.CMDCalculate(AllDemo.java:13)
at AllDemo.main(AllDemo.java:6)
----欢迎使用命令行除法计算器----
----欢迎使用命令行除法计算器----
1
r
Exception in thread "main" java.util.InputMismatchException
at java.util.Scanner.throwFor(Scanner.java:864)
at java.util.Scanner.next(Scanner.java:1485)
at java.util.Scanner.nextInt(Scanner.java:2117)
at java.util.Scanner.nextInt(Scanner.java:2076)
at AllDemo.CMDCalculate(AllDemo.java:12)
at AllDemo.main(AllDemo.java:6)
*****************************************/
import java.io.FileInputStream;
import java.io.IOException;
public class ExceptionTest {
public void testException() throws IOException {
//FileInputStream的构造函数会抛出FileNotFoundException
FileInputStream fileIn = new FileInputStream("E:\\a.txt");
int word;
//read方法会抛出IOException
while ((word = fileIn.read()) != -1) {
System.out.print((char) word);
}
//close方法会抛出IOException
fileIn.close();
}
}2.常见异常
java.lang.RuntimeException: 运行时异常
ClassCastException: 类类型转换异常，当试图将对象强制转换为不是实例的子类时，抛出该异常；
ArrayIndexOutOfBoundsException: 数组下标越界异常，当你使用不合法的索引访问数组时会抛出该异常；
NullPointerException: 空指针异常，通过null进行方法和属性调用会抛出该异常；
ArithmeticException: 算术运算异常，除数为0，抛出该异常；
NumberFormatException: 数字转换异常，当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常；
InputMismatchException: 输入不匹配异常，输入的值数据类型与设置的值数据类型不能匹配。
...
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Date;
import java.util.Scanner;
public class ExceptionTest {
//ClassCastException
public void test1() {
Object obj = new Date();
String str = (String) obj;
}
//IndexOutOfBoundsException
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
public void test3() {
int[] arr = null;
System.out.println(arr[3]);
String str = "abc";
str = null;
System.out.println(str.charAt(0));
}
//ArithmeticException
public void test4() {
int a = 10;
int b = 0;
System.out.println(a / b);
}
//NumberFormatException
public void test5() {
String str = "123";
str = "abc";
int num = Integer.parseInt(str);
}
//InputMismatchException
public void test6() {
Scanner scanner = new Scanner(System.in);
int score = scanner.nextInt();
System.out.println(score);
scanner.close();
}
}
三、异常处理的处理机制
在编写程序时，经常要在可能出现错误的地方加上检测的代码，如进行x/y运算时，要检测分母为0，数据为空，输入的不是数据而是字符等。过多的if-else分支会导致程序的代码加长、臃肿，可读性差。因此采用异常处理机制。
在编写代码处理异常时，对于检查异常/非检查异常，都有2种不同的处理方式：
1、使用try...catch...finally语句块处理它。
2、在函数签名中使用throws 声明交给函数调用者caller去解决。
比如现有一辆车,这个车你可以是方法,这辆车在可能存在各种风险,那么对于这些风险的处理方式,就相当于异常的处理方式:
1、使用try...catch...finally语句块处理它。
我们把这辆车可能出现的问题都考虑清楚了,并提供了备选方案(出现问题怎么做),如果没有出现问题,那么用不到备选方案；
如果出现了问题，根据问题去找对应的备选方案，以保证车的正常运行；
如果出现了问题,但是又没备选方案,那么车就跑不了;
2、在函数签名中使用throws 声明交给函数调用者caller去解决。
我知道车可能又问题，但是我不处理，谁来使用了，告诉调用者，这里可能有问题；
那么调用者可以处理这个问题，也可以不处理；如果它不处理，还是会出现问题，如果处理了，肯定没问题；
A -》 B -》 C
Java采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁、优雅，并易于维护。
Java提供的是异常处理的抓抛模型。
Java程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出(throw)异常。
异常对象的生成:
由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出。
由开发人员手动创建：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样。
异常的抛出机制:
如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。
如果一个异常回到main()方法，并且main()也不处理，则程序运行终止。
程序员通常只能处理Exception，而对Error无能为力。
异常处理 抓抛模型
过程一：“抛” 程序在正常执行过程中 一旦出现异常 就会在异常代码处生成一个对应异常类的对象
并将此对象抛出
一旦抛出对象以后 其后的代码就不再执行
过程二：“抓” 可以理解为异常的处理方式 1.try-catch-finally 2 throws
使用try将可能出现的异常代码包装起来 用catch去包装异常然后处理
一旦catch处理完直接跳出 继续执行其后的代码
满足子类的关系的话 子类一定要在父类的上面 否则报错
try里的变量出了try不能用 所以可以先在外面声明 然后在里面赋值
异常处理机制一：try-catch-finally
语法格式：
try{
...... //可能产生异常的代码
}
catch( ExceptionName1 e ){
...... //当产生ExceptionName1型异常时的处置措施
}
catch( ExceptionName2 e ){
...... //当产生ExceptionName2型异常时的处置措施
}
[ finally{
...... //无论是否发生异常，都无条件执行的语句
} ]
语法解释：
try：
捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中。
如果发生异常，则尝试去匹配catch块，catch块可以有多个（因为try块可以出现多个不同类型异常）;
如果执行完try不管有没有发生异常，则接着去执行finally块和finally后面的代码（如果有的话）。
catch (Exceptiontype e)：
在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
每一个catch块用于捕获并处理一个特定的异常，或者这异常类型的子类。Java可以将多个异常声明在一个catch中。 catch(Exception1 | Exception2 | Exception3 e)
catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的，则虚拟机将使用这个catch块来处理异常。
在catch块中可以使用这个块的异常参数来获取异常的相关信息。异常参数是这个catch块中的局部变量，其它块不能访问。与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。
①、getMessage() 获取异常信息，返回字符串。
②、printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
如果当前try块中发生的异常在后续的所有catch中都没捕获到，则先去执行finally，然后到这个函数的外部caller中去匹配异常处理器。
如果try中没有发生异常，则所有的catch块将被忽略。
注意：如果明确知道产生的是何种异常，可以用该异常类作为catch的参数；也可以用其父类作为catch的参数。比如：可以用 ArithmeticException 类作为参数的地方，就可以用RuntimeException类作为参数，或者用所有异常的父类Exception类作为参数。但不能是与ArithmeticException类无关的异常，如NullPointerException（catch中的语句将不会执行）。
finally：
finally块通常是可选的。捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。
不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，finally块中的语句都会被执行。
一个try至少要有一个catch块，否则， 至少要有1个finally块。但是finally不是用来处理异常的，finally不会捕获异常。
finally主要做一些清理工作，如流的关闭，数据库连接的关闭等。 public class Test_Input_01 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
/*
* 当我们只写一个try{}的时候,会报错:
* Syntax error, insert "Finally" to complete TryStatement
* 语法错误，插入“Finally”来完成Try块
*
* 总结: try不能单独存在,必须结合catch或finally来使用
* try块中没有异常,会执行finally(如果有)
* try块中有异常,会执行对应的catch块(如果有),try中异常发生点之后的代码将不会执行
*/
try{
//try块中放可能发生异常的代码。
//如果执行完try且不发生异常，则接着去执行finally块和finally后面的代码（如果有的话）。
//如果发生异常，则尝试去匹配catch块。异常点之后的代码不会运行
//这行代码有可能出错
int num1 = sc.nextInt(); //这行代码如果出现异常,那么后面的输出语句就不执行
int num2 = sc.nextInt();
System.out.println(num1+"\t"+num2);
System.out.println(num1/num2);
String str = null;
System.out.println(str.charAt(0));
}catch(InputMismatchException | NullPointerException e) {
// catch(异常对象) 当异常发生了,catch就会捕获对应的异常
// 每一个catch块用于捕获并处理一个特定的异常，或者这异常类型的子类。Java7中可以将多个异常声明在一个catch中。 catch(Exception1 | Exception2 | Exception3 e)
// catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的，则虚拟机将使用这个catch块来处理异常。
// 在catch块中可以使用这个块的异常参数来获取异常的相关信息。异常参数是这个catch块中的局部变量，其它块不能访问。
// 如果当前try块中发生的异常在后续的所有catch中都没捕获到，则先去执行finally，然后到这个函数的外部caller中去匹配异常处理器。
// 如果try中没有发生异常，则所有的catch块将被忽略。
System.out.println("catch块 - try里面发生了异常 - 空指针和输入不匹配异常都走这个Catch");
}catch(java.lang.ArithmeticException e){
e.getMessage();
System.out.println("算数异常:除数不能为0");
}catch(Exception e){
System.out.println("程序发生未知异常");
}finally {
// finally块通常是可选的。
// 无论异常是否发生，异常是否匹配被处理，finally都会执行。
// 一个try至少要有一个catch块，否则， 至少要有1个finally块。但是finally不是用来处理异常的，finally不会捕获异常。
// finally主要做一些清理工作，如流的关闭，数据库连接的关闭等。
System.out.println("finally块");
}
System.out.println("异常捕获之后的代码");
}
} 异常处理机制二：throws -------> 抛出给调用方法的人
throws是另一种处理异常的方式，它不同于try...catch...finally，throws仅仅是将函数中可能出现的异常向调用者声明，而自己则不具体处理。
throws声明：如果一个方法内部的代码会抛出检查异常（checked exception），而方法自己又没有完全处理掉或并不能确定如何处理这种异常，则javac保证你必须在方法的签名上使用throws关键字声明这些可能抛出的异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理，否则编译不通过。
在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。
采取这种异常处理的原因可能是：方法本身不知道如何处理这样的异常，或者说让调用者处理更好，调用者需要为可能发生的异常负责。
四、手动抛出异常：throw------>自己生成一个异常然后将其抛出
声明异常后果
Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要使用人工创建并抛出。
首先要生成异常类对象，然后通过throw语句实现抛出操作(提交给Java运行环境)。
throw exceptionObject
程序员也可以通过throw语句手动显式的抛出一个异常。throw语句的后面可以抛出的异常必须是Throwable或其子类的实例。下面的语句在编译时将会产生语法错误：
throw new String("你抛我试试.");
throw 语句必须写在函数中，执行throw 语句的地方就是一个异常抛出点，它和由JRE自动形成的异常抛出点没有任何差别
public class StudentTest {
public static void main(String[] args) {
try {
Student s = new Student();
s.regist(-1001);
System.out.println(s);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
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("您输入的数据非法！");
//错误的
// throw new String("不能输入负数");
}
}
@Override
public String toString() {
return "Student [id=" + id + "]";
}
}throws和throw的区别:
throw是语句抛出一个异常。
语法：throw (异常对象);
throw e;
throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)
语法：[(修饰符)](返回值类型)(方法名)([参数列表])[throws(异常类)]{......}
public void doA(int a) throws Exception1,Exception3{......}
throw语句用在方法体内，表示抛出异常，由方法体内的语句处理。
throws出现在方法函数头，表示在抛出异常，由该方法的调用者来处理。
throws主要是声明这个方法会抛出这种类型的异常，使它的调用者知道要捕获这个异常。
throw是具体向外抛异常的动作，所以它是抛出一个异常实例。
throws说明你有那个可能，倾向。
throw的话，那就是你把那个倾向变成真实的了。
两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。
总结
提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了异常处理的基础知识