概述：

1、程序在执行过程中发生了不正常的情况，而这种不正常的情况就叫做：异常

例如：

System.out.println(10/0);

这个语句在控制台会输出：

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at excption.ExceptionTest01.main(ExceptionTest01.java:5)

异常信息是由JVM打印的。

2、java中异常是以类的形式存在，每一个异常类都可以创建对象。

异常继承结构：

1、Throwable继承Object类

2、Error（错误）和Exception（异常）继承Throwable类；

3、ExceptionSubClass（编译时异常）和RuntimeException（运行时异常）继承Exception类

4、Error（错误）一旦发生就会终止运行，退出JVM虚拟机，错误是不能处理的；

5、ExteptionSubClass（编译时异常）：编译时异常表示必须在编写程序的时候预先对这种异常进行处理，不然编译时发生异常的概率较高，编译异常又叫做受检异常或者受控异常

6、RuntimeException（运行时异常）：运行时异常在编写程序的阶段可以处理也可以不处理，运行时发生的概率较低，运行时异常又叫做未受检异常或者未受控异常

异常的两种处理方式：

1、在方法声明的位置上使用throws关键字把异常抛给上一级（异常上抛）；

2、使用try..catch语句进行异常的捕捉；（异常捕捉）；

3、如果异常一直上抛，main方法抛给JVM，只有一个结果就是终止程序；

异常上抛：

public class ExceptionTest01 {
    //main方法依然继续上抛，抛给JVM，JVM会终止程序
    public static void main(String[] args) throws ArithmeticException{
        m1();
    }
    //异常继续上抛，抛给main方法
    private static void m1() throws ArithmeticException{
        m2();
    }
    //异常继续上抛，抛给m1
    private static void m2() throws ArithmeticException{
        m3();
    }
    //异常上抛给m2
    private static void m3() throws ArithmeticException{
        System.out.println(10/0);
    }
    /*异常信息：
    Exception in thread "main" java.lang.ArithmeticException: / by zero
    at excption.ExceptionTest01.m3(ExceptionTest01.java:18)
    at excption.ExceptionTest01.m2(ExceptionTest01.java:14)
    at excption.ExceptionTest01.m1(ExceptionTest01.java:10)
    at excption.ExceptionTest01.main(ExceptionTest01.java:6)
*/
}

异常捕捉：

public class ExceptionTest01 {
    //main方法选择捕捉异常（异常捕捉）
    public static void main(String[] args) {
        //使用try..catch进行捕捉
        try {
            m1();
        } catch (ArithmeticException e) {
            //打印堆栈信息
            e.printStackTrace();
        }
        //异常捕捉处理后，虽然打印了异常信息，但是JVM没有终止程序，所以以下的内容还是会被打印
        System.out.println("hello!");
        System.out.println("world");


    }
    //异常继续上抛，抛给main方法
    private static void m1() throws ArithmeticException{
        m2();
    }
    //异常继续上抛，抛给m1
    private static void m2() throws ArithmeticException{
        m3();
    }
    //异常上抛给m2
    private static void m3() throws ArithmeticException{
        System.out.println(10/0);
    }
    /*控制台输出：
    java.lang.ArithmeticException: / by zero
    at excption.ExceptionTest01.m3(ExceptionTest01.java:29)
    at excption.ExceptionTest01.m2(ExceptionTest01.java:25)
    at excption.ExceptionTest01.m1(ExceptionTest01.java:21)
    at excption.ExceptionTest01.main(ExceptionTest01.java:8)
    hello!
    world
    */


}

注意：如果异常希望调用者来处理就选择上抛；

深入try..catch：

public class ExceptionTest01 {
    //main方法选择捕捉异常（异常捕捉）
    public static void main(String[] args) {
        //使用try..catch进行捕捉
        try {
            m3();
            //括号里异常信息可以写多个
        } catch (ArithmeticException e) {
            //catch发生异常才会执行

            //打印堆栈信息
            //e.printStackTrace();
            //也可以直接输出
            //System.out.println("除数不能为0");
            //也可以打印简洁信息
            e.getMessage();
         //也可以写多个 catch,写多个catch需要注意从上到下需要从小到大的写 ；
        }/*catch(Exception e){
            e.getMessage();
        }*/
    }

    //异常上抛给main
    private static void m3() throws ArithmeticException{
        System.out.println(10/0);
    }
}

finally语句：

public class ExceptionTest01 {
    //main方法选择捕捉异常（异常捕捉）
    public static void main(String[] args) {
        //使用try..catch进行捕捉
        try {
            m3();
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }finally {
            //这里的语句不管异常发不发生，都会执行
            System.out.println("hello world!");
        }
    }
    //异常上抛给main
    private static void m3() throws ArithmeticException{
        System.out.println(10/0);
    }
}

自定义异常：

1、编写一个类继承Exception或者RuntimeException

2、提供两个构造方法，一个无参一个带有String参数的；

例如（异常类）：

//定义自己的异常类继承Exception
public class MyException extends Exception{
    //无参构造
    public MyException() {
    }
    //带有String的有参构造
    public MyException(String s) {
        super(s);
    }
}

测试类：

public class ExceptionTest01 {
    public static void main(String[] args) {
        //异常捕捉
        try {
            print(2);
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
    //异常上抛
    public static void print(int a) throws MyException {
        //例如a等于二就会抛出异常
        if(a==2){
            //异常抛出
            throw new MyException("a不能等于2!");
        }
    }
    /*异常信息
    excption.MyException: a不能等于2!
    at excption.ExceptionTest01.print(ExceptionTest01.java:16)
    at excption.ExceptionTest01.main(ExceptionTest01.java:7)*/
}