5、java异常

java异常

1、异常的描述：
    异常指在运行时期发生的不正常情况。
    在java中用类的形式对不正常情况进行了描述和封装对象。
    描述不正常情况的类，就成为异常类。
    将正常代码和问题处理代码分离，提高阅读性。

    其实异常就是java通过面向对象的思想将问题封装成了对象，用异常类对其进行描述。


2、异常的体系：
    两大类:
        父类————Throwable：可抛出的异常，无论是error还是exception，问题发生就应该可以抛出，让调用者知道并且处理。
        该体系的特点就是在于Throwable及其所有的子类都具有可抛性。

            可抛性到底指的是什么？怎么体现可抛性呢？
                通过两个关键字来体现的。
                    throws throw 凡是可以被这两个关键字所操作的类和对象都具有可抛性。

            子类1)一般不可处理的。————Error
                特点：是由jvm抛出的严重性问题，这种问题发生一般不针对性处理，直接修改程序。

            子类2）可以处理的。————Exception，问题抛给调用者，谁用抛给谁。

        该体系特点：子类后缀名都是用其父类名作为后缀名，阅读性很强！

    范例：比如自定义一个负数角标的异常，使用面向对象思想封装成对象。
        注意：如果让一个类称为异常类，必须要继承异常类。因为只有异常体系的子类才具有可抛性。

        class FuShuIndex extends Exception{
            //构造函数 和类名一样
            FuShuIndex(){  
            }
            //定义一个带参数的构造函数
            FuShuIndex(String msg){
                //调用Exception中的带参数异常函数
                super(msg);  
            }
        }
        主函数 throws FuShuIndex：{
           int[] arr = new int[3];
           method(arr,-7);
        }
        public static int method(int[] arr,int index) throws arrIndexexception {
             if (index<0){
                throw new arrIndexexception("数组的角标不能为负数");
             }
            return arr[index];
        }


3.异常的分类：
    1）编译时被检测异常还要是Exception和其子类都是，除了特殊子类RuntimeException体系
        未处理即编译失败！
        这种问题一旦出现，希望在编译时就进行检测，让这种问题有相应的处理方式，这样的问题都可以针对性处理。


    2）编译时不被检测异常（运行时异常）：RuntimeException和其子类
        可处理可不处理，编译都可以通过，运行时会检测！
        这种问题的发生，无法让功能继续，运算无法运行，更多因为调用的原因导致，或者引发了内部状态的改变导致的。这种问题一般不处理，直接编译通过，在运行时，让调用者时程序强制停止，让调用者对代码进行修正。

    throws和throw的区别：
        1.throws使用在函数上  ————申明 
          throw使用在函数内，可以抛出多个，用逗号隔开。 ————抛出
        2. throws抛出的是异常类，可以抛出多个。
            throw抛出的是异常对象。


4.异常处理的捕捉形式：
    这是可以对异常进行针对性处理的方式。
    
    格式：
        try{
            //需要被检测异常的代码
        }
        catch(异常类 变量)//该变量用于接收发生的异常对象{
            //处理异常代码
        }
        finally{
            //一定会被执行的代码
        }

    范例：修改自定义异常的范例，方便阅读
        class FuShuIndex extends Exception{
            //构造函数 和类名一样
            FuShuIndex(){  
            }
            //定义一个带参数的构造函数
            FuShuIndex(String msg){
                //调用Exception中的带参数异常函数
                super(msg);  
            }
        }
        主函数 //无需throws抛出，下面我们自己捕获异常：{
           int[] arr = new int[3];
           try{
           method(arr,-7);
           }catch(arrIndexexception a){
                a.printStackTrace();//jvm默认的异常处理机制就是调用异常对象的这个方法。
                System.out.println("数组的角标异常！！！");//自定义捕获后打印的信息
                System.out.println(a.toString());//打印该异常对象的信息
                System.out.println(a.getMessage());//获取我们自定义抛出所定义的信息
                }
        }
        public static int method(int[] arr,int index) throws arrIndexexception {
             if (index<0){
                throw new arrIndexexception("数组的角标不能为负数");
             }
            return arr[index];
        }

    一个try对应多个catch：
        多catch情况下，父类的catch要放在最下面，否则编译为空。


5、异常处理的原则：
    1）函数内部如果抛出了需要检测的异常，那么函数上必须申明，或者必须在函数内用try catch捕捉，否则编译失败。
    2）如果调用到了申明异常的函数，要么try catch 或者 throws ，否则编译失败。
    3）什么时候catch？什么时候throws？
        功能内容可以解决，用catch。
        解决不了，用throws告诉调用者，由调用者解决。
    4）一个功能如果抛出了多个异常，那么调用时，必须有对应的多个catch来进行针对性处理。
        内部有几个需要检测的异常，就抛几个异常，抛出几个就catch几个异常。


6、finally：
    通常用于关闭（释放）资源。必须要执行。除非jvm虚拟机挂了。
    范例：
        出门玩，必须关门，所以将关门这个动作放在finally里面，必须执行。

    凡是涉及到关闭连接等操作，要用finally代码块来释放资源。

    try catch finally 代码块组合特点：
        
        1）try catch finally
            当有资源需要释放时，可以定义finally
        2）try catch(多个) 
            当没有资源需要释放时，可以不定义finally
        3）try finally
            异常处理不处理我不管，但是我得关闭资源，因为资源是我开的，得在内部关掉资源。
            范例：
                try{
                    //连接数据库
                }
                    //没有catch意思不处理异常，只单纯的捕获异常
                finally{
                    //关闭连接
                }


7、异常的应用:
    丁老师用电脑讲课范例：
        电脑类：
            public class Computer {
                private int state = 2;
                public void run() throws lanpingExcption,maoyanExcption{
                    if (state == 1){
                        throw new lanpingExcption("电脑蓝屏啦～");
                    }else if (state == 2){
                        throw new maoyanExcption("电脑冒烟啦～");
                    }
                    System.out.println("电脑启动");
                }
                public void chongqi(){
                    state = 0;
                    System.out.println("重启电脑！");
                }
            }
        老师类：
            public class Teacher {
            private String name;
            private Computer computer;
            Teacher(String name){
                this.name = name;
                computer = new Computer();
            }

            void teach() throws maoyanExcption{
                try {
                    computer.run();
                    System.out.println(this.name + "开始用电脑讲课了");
                } catch (lanpingExcption l) {
                    l.printStackTrace();
                    computer.chongqi();
                    teach();//重启后再次讲课
                } catch (maoyanExcption m) {
                    m.printStackTrace();
                    test();
                    throw m;
                }
            }

            public void test(){
                System.out.println("大家自己练习去～");
            }

            }
        蓝屏异常类：
        public class lanpingExcption extends Exception{
            lanpingExcption (String msg){
                 super(msg);
            }
        }
        冒烟异常类：
        public class maoyanExcption extends Exception {
            maoyanExcption (String msg){
                super(msg);
            }
        }
        主函数：
        public class Testmain {
            public static void main (String[] args){
                Teacher teacher = new Teacher("丁老师");
                try {
                    teacher.teach();
                } catch (maoyanExcption m) {
                    //m.printStackTrace();
                    System.out.println("。。。。。");
                }
            }
        }


8、异常的注意事项：
    1）子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。
    2）如果父类抛出多个异常，那么子类只能抛出父类异常的子集。
    3）子类覆盖父类，只能抛出父类的异常或者子类。
    4）如果父类的方法没有抛出异常，子类覆盖时绝对不能抛。