异常是什么？
第一，异常模拟的是现实世界中“不正常的”事件。
第二，java中采用”类“去模拟异常。java的异常都是类，我们可以通过这个类把信息取出来，做一些特殊处理使程序更加健壮 。
第三，类是可以创建对象的， NullPointerException e = ox1234；e是引用类型， e中保存的内存地址指向堆中的对象。这个对象一定是NullPointerException类型。这个对象就表示真实存在的异常事件。NullPointerException是一类异常。
”抢劫“就是一类异 张三被抢劫就是一个异常事件。李四被抢劫都归抢劫事件一类。
2.异常机制的作用？
java语言为我们提供一种完善的异常处理机制。
作用是：程序发生异常事件之后，为我们输出详细的信息，程序员通过这个信息，可以对程序进行一些处理，使程序更加健壮。
public static void main(String[] args){
int a = 10;
int b = 0;
int c = a/b; //ArithMeticException e = 0x2356;
System.out.println("Hello World!");
//上面的代码出现了异常，“没有处理”，下面的代码不会执行，直接退出了JVM。
以上程序编译通过了，但是运行时出现了异常，表示发生某个异常事件。JVM向控制台输出如下的信息：
本质：程序执行过程中发生了算数异常这个事件，JVM为我们创建了一个ArithmeticException类型的对象。并且这个对象中包含了详细的异常信息，并且JVM将这个对象中的信息输出到控制台。
Exception in thread "main" java.lang.ArithmeticException: / by zero
at ExceptionTest01.main(ExceptionTest01.java:25)
2.异常的继承结构图
Throwable形容词，可抛出的，继承与objcet，所有的异常都是可抛出的，
StackOverFlowError 栈内存溢出
编译时异常和运行时异常的区别：如上图
在我们代码级别上，所有runtimeException的子类都是运行时异常，所有Exception的直接子类都是编译时异常，在语法上规定，编译时异常要求程序员在编写阶段必须处理，如果不处理的话，编译都无法通过。如果异常时runtimeException，那么程序猿在编写阶段对它不需要处理 ，和现实世界对比，编译时异常发生几率是比较高的，运行时异常发生几率是比较低的。
2.1 处理异常的两种方式
1. 声明抛出
2 捕捉 try……catch……
以下程序演示第一种方式：声明抛出，在方法声明的位置上使用throws关键字向上抛出异常
处理异常的第二种方式：捕捉.. try...catch...
语法：
try{
可能出现异常的代码;
}catch(异常类型1 变量){
处理异常的代码;
}catch(异常类型2 变量){
处理异常的代码;
}....
1.catch语句块可以写多个.
2.但是从上到下catch,必须从小类型异常到大类型异常进行捕捉。（先捕捉子类，后捕捉父类）
3.try...catch...中最多执行1个catch语句块。执行结束之后try...catch...就结束了。
public static void main(String[] args){
//以下代码编译无法通过，因为FileNotFoundException没有处理.
/*
try{
//FileNotFoundException
FileInputStream fis = new FileInputStream("c:/ab.txt");
}catch(ArithmeticException e){ //捕获的异常是算术异常
}
*/
//编译通过
/*
try{
//FileNotFoundException
FileInputStream fis = new FileInputStream("c:/ab.txt");
}catch(FileNotFoundException e){
}
*/
//以下程序编译无法通过
//因为还有更多IOException没有处理.
/*
try{
//FileNotFoundException
FileInputStream fis = new FileInputStream("c:/ab.txt");
fis.read();
}catch(FileNotFoundException e){
}
*/
//编译可以通过
/*
try{
//FileNotFoundException
FileInputStream fis = new FileInputStream("c:/ab.txt");
fis.read();
先捕捉子类后捕捉父类
}catch(FileNotFoundException e){
}catch(IOException e){
}
*/
//编译通过.
/*
try{
FileInputStream fis = new FileInputStream("c:/ab.txt");
fis.read();
}catch(IOException e){
}
*/
//编译无法通过
//catch可以写多个，但是必须从上到下，从小到大捕捉。
/*
try{
FileInputStream fis = new FileInputStream("c:/ab.txt");
fis.read();
}catch(IOException e){
}catch(FileNotFoundException e){
}
/*关于getMessage和printStackTrace方法的应用.*/
import java.io.*;
public class ExceptionTest07{public static void main(String[] args){
try{
FileInputStream fis = new FileInputStream("c:/abc.txt");
//JVM为我们执行了一下这段代码//FileNotFoundException e = new FileNotFoundException("c:\abc.txt (系统找不到指定的文件。)");
}catch(FileNotFoundException e){
//打印异常堆栈信息.//一般情况下都会使用该方式去调试程序.
//e.printStackTrace();
/*java.io.FileNotFoundException: c:\abc.txt (系统找不到指定的文件。)
at java.io.FileInputStream.open(Native Method)
at java.io.FileInputStream.(FileInputStream.java:106)
at java.io.FileInputStream.(FileInputStream.java:66)
at ExceptionTest07.main(ExceptionTest07.java:13)
*/
String msg = e.getMessage();
System.out.println(msg); //c:\abc.txt (系统找不到指定的文件。)（ui它打印的信息只是第一个方法的一部分，所以推荐使用第一个）
}
//这段代码会执行.（因为上面处理了，所以会执行）
System.out.println("ABC");
}
}
/*
关于finally语句块
1.finally语句块可以直接和try语句块联用。 try....finally...
2.try...catch....finally 也可以.（finally使用就这两种方法）
3.在finally语句块中的代码是一定会执行的。
4（只有一种情况不会执行，例子在下面）//只要在执行finally语句块之前退出了JVM，则finally语句块不会执行.
*/
import java.io.*;
public class ExceptionTest08{
public static void main(String[] args) throws Exception{
/*
try{
System.out.println("ABC");
return;
}finally{
System.out.println("Test");
／／这里的执行顺序可以这么理解，先打印try，后打印finally，再执行try里的return。
}
*/
/*
try{
FileInputStream fis = new FileInputStream("Test.java");
//不会执行（因为这没有处理就不会打印）
System.out.println("TTTT");
}finally{
//会执行
System.out.println("AAAAA");
}
*/
//只要在执行finally语句块之前退出了JVM，则finally语句块不会执行.
try{
//退出JVM
System.exit(0);
}finally{
//不会执行.
System.out.println("finally....");
}
}
}
/*
深入finally语句块
*/
public class ExceptionTest09{
public static void main(String[] args){
int i = m1();
System.out.println(i); //10
}
public static int m1(){
int i = 10;
try{
return i;
}finally{
i++;
System.out.println("m1的i=" + i); //11
}
//以上代码的执行原理
/*
int i = 10;
try{
int temp = i;
return temp;
}finally{
i++;
System.out.println("m1的i=" + i); //11
}
*/
}
}
/*
finally语句块是一定会执行的，所以通常在程序中
为了保证某资源一定会释放，所以一般在finally语句块
中释放资源。
注意：受控异常就是编译时异常。
非受控异常就是运行时异常。
*/
import java.io.*;
public class ExceptionTest10{
public static void main(String[] arg){
//必须在外边声明
FileInputStream fis = null;
try{
fis = new FileInputStream("ExceptionTest10.java");
}catch(FileNotFoundException e){
e.printStackTrace();
}finally{
//为了保证资源一定会释放.
if(fis!=null){
try{
fis.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
}
}
关于getMessage 和printStackTrace()方法的应用
异常机制的作用？