异常

现实生活的病

现实生活中万物在发展和变化会出现各种各样不正常的现象。

    例如：人的成长过程中会生病。
        |——病
            |——不可治愈(癌症晚期)
            |——可治愈
                |——小病自行解决(上火,牙痛)
                |——去医院(感冒,发烧)

java异常体系图

现实生活中的很多病况从面向对象的角度考虑也是一类事物，可以定义为类。

java中可以通过类对这一类不正常的现象进行描述，并封装为对象。
1.java的异常体系包含在java.lang这个包默认不需要导入。
2.java异常体系
        |——Throwable  （实现类描述java的错误和异常）
            |——Error （错误）一般不通过代码去处理。
            |——Exceprion （异常）
                |——RuntimeException （运行时异常）
                |——非运行时异常
常见的Error

 错误原因：内存溢出。需要的内存已经超出了java虚拟机管理的内存范围。

错误原因：找不到类文件。
错误(Error):
它指的是一个合理的应用程序不能截获的严重的问题。大多数都是反常的情况。错误是JVM的一个故障(虽然它可以是任何系统级的服务)。所以，错误是很难处理的，一般的开发人员(当然不是你)是无法处理这些错误的。比如内存溢出.            
3.异常体系图的对应

Throwable类

1.toString() 输出该异常的类名。
2.getMessage() 输出异常的信息，需要通过构造方法传入异常信息（例如病态信息）。
3.printStackTrace() 打印栈信息。
人生病：流鼻涕，感冒，呼吸道感染，肺炎。。。最后体现的是肺炎。

医生要处理需要获知这些信息。从外到里处理。最后找病源

/*
 Throwable类

 printStackTrace() 打印栈信息

 肺炎
 上呼吸道感染
 发烧
 流鼻涕感冒
 小感冒    
 */
class Demo6 {

    public static void main(String[] args) {

        // Throwable able=new Throwable();
        Throwable able = new Throwable("想吐。。。");
        System.out.println(able.toString()); // 输出该异常的类名
        System.out.println(able.getMessage()); // 输出异常的信息
        able.printStackTrace(); // 打印栈信息
    }
}

程序中的异常处理

1.当除数是非0，除法运算完毕，程序继续执行。
2.当除数是0，程序发生异常，并且除法运算之后的代码停止运行。因为程序发生异常需要进行处理。

class Demo7 {

    public static void main(String[] args) {
        div(2, 0);
        System.out.println("over");
    }

    public static void div(int x, int y) {
        //该行代码的y值可能是0,程序会出现异常并停止
        System.out.println(x / y);
        System.out.println("除法运算");
    }
}
//ArithmeticException 

疑问： 出现异常如何处理？

自行处理

1.try{//可能发生异常的代码 }catch(异常类 变量名){//处理}。
2.案例除法运算的异常处理。
3.如果没有进行try catch处理，出现异常程序就停止。进行处理后，程序会继续执行。

class Demo7 {

    public static void main(String[] args) {
        div(2, 0);
        System.out.println("over");
    }

    public static void div(int x, int y) {

        try {
            System.out.println(x / y); // 可能出现异常的语句，放入try中。
        } catch (ArithmeticException e) { // 进行异常匹配，
             //异常信息
            System.out.println(e.toString());
                System.out.println(e.getMessage());    
         e.printStackTrace();
            System.out.println("除数不能为0");
        }
        System.out.println("除法运算");
    }
}

多个异常

1.案例print方法，形参中增加数组。
2.在print方法中操作数组会发生新的异常
ArrayIndexOutOfBoundsException，NullPointerException），如何处理？
    1.使用将可能发生异常的代码放入try语句中，添加多个catch语句即可。
    2.可以处理多种异常，但是同时只能处理一种异常。
    3.try中除0异常和数组角标越界同时出现，只会处理一种。

public class Demo8 {

    public static void main(String[] args) {

        System.out.println();
        int[] arr = { 1, 2 };
        arr = null;

        // print (1, 0, arr);
        print (1, 2, arr);

        System.out.println("over");
    }    

    public static void print(int x, int y, int[] arr) {

        try {
            System.out.println(arr[1]);
            System.out.println(x / y);
        } catch (ArithmeticException e) {
            e.toString();
            e.getMessage();
            e.printStackTrace();
            System.out.println("算术异常。。。");
        } catch (ArrayIndexOutOfBoundsException e) {
            e.toString();
            e.getMessage();
            e.printStackTrace();
            System.out.println("数组角标越界。。。");
        } catch (NullPointerException e) {
            e.toString();
            e.getMessage();
            e.printStackTrace();
            System.out.println("空指针异常。。。");
        }
        System.out.println("函数执行完毕");
    }
}

总结

1.程序中有多个语句可能发生异常，可以都放在try语句中。并匹配对个catch语句处理。
2.如果异常被catch匹配上，接着执行try{}catch(){} 后的语句。没有匹配上程序停止。
3.try中多个异常同时出现，只会处理第一条出现异常的一句，剩余的异常不再处理。
4.使用多态机制处理异常。

1.程序中多态语句出现不同异常，出现了多个catch语句。简化处理（相当于急诊）。
2.使用多态，使用这些异常的父类进行接收。（父类引用接收子类对象）

public static void div(int x, int y, int[] arr, Father f) {

        try {
            System.out.println(arr[1]); // 数组越界
            System.out.println(x / y); // 除零
            Son s = (Son) f; // 类型转换

        } catch (Exception e) {
            e.toString();
            e.getMessage();
            e.printStackTrace();
            System.out.println("出错啦");
        }
        System.out.println("函数执行完毕");
    }

多个catch语句之间的执行顺序。
1.是进行顺序执行，从上到下。
2.如果多个catch 内的异常有子父类关系。
1.子类异常在上，父类在最下。编译通过运行没有问题
2.父类异常在上，子类在下，编译不通过。(因为父类可以将子类的异常处理，子类的catch处理不到)。
3.多个异常要按照子类和父类顺序进行catch

class Father {

}

class Son extends Father {

}

public class Demo8 {

    public static void main(String[] args) {

        System.out.println();
        int[] arr = { 1, 2 };
        arr = null;
        Father f = new Father();
        div(1, 0, arr, f);
        
        System.out.println("over");
    }

    public static void div(int x, int y, int[] arr, Father f) {

        try {
            System.out.println(arr[1]); 
            System.out.println(x / y);
            Son s = (Son) f;

        } catch (ArithmeticException e) {
            e.toString();
            e.getMessage();
            e.printStackTrace();
            System.out.println("算术异常。。。");
        } catch (ArrayIndexOutOfBoundsException e) {
            e.toString();
            e.getMessage();
            e.printStackTrace();
            System.out.println("数组角标越界。。。");
        } catch (NullPointerException e) {
            e.toString();
            e.getMessage();
            e.printStackTrace();
            System.out.println("空指针异常。。。");
        } catch (Exception e) {
            e.toString();
            e.getMessage();
            e.printStackTrace();
            System.out.println("出错啦");
        }
        System.out.println("函数执行完毕");
    }
}

总结
处理异常应该catch异常具体的子类，可以处理的更具体，不要为了简化代码使用异常的父类。

疑惑：感觉异常没有作用.