异常
1. Throwable： 有两个重要的子类：Exception（异常）和Error（错误）
2. Error： 程序无法处理的错误。大多数错误与代码编写者执行的操作无关，而表示代码运行时JVM出现的问题，例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
3. Exception： 是程序本身可以处理的异常
-
RuntimeException
表示JVM常用操作引发的错误，例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。 -
JAVA异常（包括Exception和Error）分为可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。
可查异常
除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。不可查异常：包括运行时异常（RuntimeException与其子类）和错误（Error）。
-
Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。
-
运行时异常
RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。运行时异常特点:Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。
非运行时异常（编译异常）
是RuntimeException以外的异常，类型上都属于Exception类及其子类。必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常
-
异常处理机制
总体来说：对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的 RuntimeException 和 Error。
捕获异常：try、catch 和 finally
1. try-catch语句
语法：
try {
// 可能会发生异常的程序代码
} catch (Type1 id1){
// 捕获并处置try抛出的异常类型Type1
}
catch (Type2 id2){
//捕获并处置try抛出的异常类型Type2
}
try后为监控区域。若出现异常，则创建异常对象，将对象抛出监控区域之外并寻找匹配的catch子句捕获异常。
匹配原则：若抛出对象属于catch句子的异常类或子类，则匹配例1 “除数为0”引发的ArithmeticException异常。
public static void main(String[] args) {
int a = 6;
int b = 0;
try {
System.out.println("a/b的值是：" + a / b);
} catch (ArithmeticException e) {
System.out.println("程序出现异常，变量b不能为0。");
}
System.out.println("程序正常结束。");
}
}
结果：
程序出现异常，变量b不能为0。
程序正常结束。
在该例中，b=0引发ArithmeticException异常，运行时系统创建异常对象并抛出监控区域，转而匹配合适的异常处理器catch，并执行相应的异常处理代码。
事实上，ArithmeticException异常属于运行时异常，由于检查运行时异常的代价远大于捕捉异常所带来的益处，所以一般不做处理例2 存在除数为0和下标越界异常
public class TestException {
public static void main(String[] args) {
int[] intArray = new int[3];
try {
for (int i = 0; i <= intArray.length; i++) {
intArray[i] = i;
System.out.println("intArray[" + i + "] = " + intArray[i]);
System.out.println("intArray[" + i + "]模 " + (i - 2) + "的值: "
+ intArray[i] % (i - 2));
}
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("intArray数组下标越界异常。");
} catch (ArithmeticException e) {
System.out.println("除数为0异常。");
}
System.out.println("程序正常结束。");
}
}
结果：
intArray[0] = 0
intArray[0]模 -2的值: 0
intArray[1] = 1
intArray[1]模 -1的值: 0
intArray[2] = 2
除数为0异常。
程序正常结束。
-
在该例中，可能会出现下标越界和除数为0两种异常，但除数为0先匹配，因此执行相应的catch语句
注意：一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会
2. try-catch-finally 语句
语法：
try {
// 可能会发生异常的程序代码
} catch (Type1 id1) {
// 捕获并处理try抛出的异常类型Type1
} catch (Type2 id2) {
// 捕获并处理try抛出的异常类型Type2
} finally {
// 无论是否发生异常，都将执行的语句块
}
- 例1 带finally子句的异常处理程序。
public class TestException {
public static void main(String args[]) {
int i = 0;
String greetings[] = { " Hello world !", " Hello World !! "};
while (i < 3) {
try {
// 特别注意循环控制变量i的设计，避免造成无限循环
System.out.println(greetings[i++]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组下标越界异常");
} finally {
System.out.println("--------------------------");
}
}
}
}
运行结果：
Hello world !
--------------------------
Hello World !!
--------------------------
数组下标越界异常
--------------------------
- 特别注意try子句中语句块的设计，如果设计为如下，将会出现死循环。
try { System.out.println (greetings[i]); i++; }
小结：
try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch 块：用于处理try捕获到的异常。
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：
1）在finally语句块中发生了异常。
2）在前面的代码中用了System.exit()退出程序。
3）程序所在的线程死亡。
4）关闭CPU。
3. try、catch、finally语句块的执行顺序
1）try中没有异常：try中顺序执行，跳过catch语句，执行finally语句和后面的语句
2）try捕获异常，没有catch匹配异常：该异常会抛给JVM处理，finally语句块还是会执行，但后面的语句不会执行
3）try捕获异常，有catch匹配并处理：出现异常，程序跳到相应的catch语句块，其他catch不会执行，try语句块中，出现异常之后的语句也不会被执行，catch执行完之后执行finally语句块，最后执行后面的语句
抛出异常
1. throws抛出异常
语法：
methodname throws Exception1,Exception2,...
{
}
- throws语句在定义方法时声明要抛出的异常类型，多个异常可以用逗号分隔。当方法抛出异常时，该方法不对这些类型的异常以及子类进行处理，而是抛向调用该方法的方法。例如：
import java.lang.Exception;
public class Test {
static void pop() throws NegativeArraySizeException {
// 定义方法并抛出NegativeArraySizeException异常
int[] arr = new int[-3]; // 创建数组
}
public static void main(String[] args) { // 主方法
try { // try语句处理异常信息
pop(); // 调用pop()方法
} catch (NegativeArraySizeException e) {
System.out.println("pop()方法抛出的异常");// 输出异常信息
}
}
}
使用throws关键字将异常抛给调用者后，如果调用者不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的调用者。
pop方法没有处理异常NegativeArraySizeException，而是由main函数来处理。throws抛出异常规则
1）不可查异常（Error，RuntimeException），可以不抛出，编译时会通过，运行时被系统抛出
2）可查异常，要么抛出，要么捕获
3）当抛出异常，该方法的调用者必须处理或者重新抛出
4）若声明一个异常，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。
例如：
void method1() throws IOException{} //合法
//编译错误，必须捕获或声明抛出IOException
void method2(){
method1();
}
//合法，声明抛出IOException
void method3()throws IOException {
method1();
}
//合法，声明抛出Exception，IOException是Exception的子类
void method4()throws Exception {
method1();
}
//合法，捕获IOException
void method5(){
try{
method1();
}catch(IOException e){…}
}
//编译错误，必须捕获或声明抛出Exception
void method6(){
try{
method1();
}catch(IOException e){throw new Exception();}
}
//合法，声明抛出Exception
void method7()throws Exception{
try{
method1();
}catch(IOException e){throw new Exception();}
}
2. 使用throws
throw用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。
-
异常是异常类的实例对象，我们可以创建异常类的实例对象通过throw语句抛出。该语句的语法格式为：
throw new exceptionname;例如抛出一个IOException类的异常对象：
throw new IOException; -
注意的是，throw 抛出的只能够是Throwable类 或者其子类的实例对象。下面的操作是错误的：
throw new String("exception"); 如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。
如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException，则该方法的调用者可选择处理该异常。
package Test;
import java.lang.Exception;
public class TestException {
static int quotient(int x, int y) throws MyException { // 定义方法抛出异常
if (y < 0) { // 判断参数是否小于0
throw new MyException("除数不能是负数"); // 异常信息
}
return x/y; // 返回值
}
public static void main(String args[]) { // 主方法
int a =3;
int b =0;
try { // try语句包含可能发生异常的语句
int result = quotient(a, b); // 调用方法quotient()
} catch (MyException e) { // 处理自定义异常
System.out.println(e.getMessage()); // 输出异常信息
} catch (ArithmeticException e) { // 处理ArithmeticException异常
System.out.println("除数不能为0"); // 输出提示信息
} catch (Exception e) { // 处理其他异常
System.out.println("程序发生了其他的异常"); // 输出提示信息
}
}
}
class MyException extends Exception { // 创建自定义异常类
String message; // 定义String类型变量
public MyException(String ErrorMessagr) { // 父类方法
message = ErrorMessagr;
}
public String getMessage() { // 覆盖getMessage()方法
return message;
}
}
JAVA常见异常
1. runtimeException子类
java.lang.ArrayIndexOutOfBoundsException
数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。java.lang.ArithmeticException
算术条件异常。譬如：整数除零等。java.lang.NullPointerException
空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等java.lang.ClassNotFoundException
找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。java.lang.NegativeArraySizeException
数组长度为负异常java.lang.ArrayStoreException
数组中包含不兼容的值抛出的异常java.lang.SecurityException
安全性异常java.lang.IllegalArgumentException
非法参数异常
2. IoException子类
- IOException：操作输入流和输出流时可能出现的异常。
- EOFException 文件已结束异常
- FileNotFoundException 文件未找到异常
