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 exceptionJava编译器不会检查这些异常，在程序中可以选择捕获处理，也可以不处理，照样正常编译通过
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
) {
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
) {
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("=====运算结束=====");
}
}
}
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{
int result
= test();
System
.out
.println("one和two的商是：" + result
);
}catch(ArithmeticException e
){
}catch(InputMismatchException e
){
}catch(Exception e
){
}
int result2
=test();
}
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
) {
try {
testAge();
} catch (HotelAgeException e
) {
System
.out
.println(e
.getMessage());
System
.out
.println("酒店前台工作人员不允许办理入住登记");
}catch(Exception e
){
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 HotelAgeException();
} else {
System
.out
.println("欢迎入住本酒店");
}
}
}
异常链
有时候我们会捕获一个异常后再抛出另一个异常顾名思义就是：将异常发生的原因一个传一个串起来，即把底层的异常信息传给上层，这样逐层抛出
package com
.sh
.test
;
public class TryDemoFive {
public static void main(String
[] args
) {
try {
testThree();
} catch (Exception e
) {
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
;
}
}
}
总结
异常异常分类异常处理（抛出异常，捕获异常）异常处理 try-catch-finally自定义异常异常链常见异常类型
