Java初学（十）

一、异常的概念
    Java语言将程序运行过程中所发生的不正常严重错误称为异常，对异常的处理称为异常处理。
二、异常分类
    
    Throwable有两个直接子类，Error类和Exception类。
        Error：指合理的应用程序在执行过程中发生的严重问题，当程序发生这种严重的错误时，通
        常做法是通知用户并终止程序的执行。
        Exception：异常可分为运行时异常（RuntimeException）和检查时异常（CheckedExcaption）
        两种：
                RuntimeException：运行时异常，即程序运行时抛出的异常。这种异常在写代码时不进行
            处理，Java源文件也能编译通过，RuntimeException异常类及其下面的子类均为运行时异常。
                CheckedException:检查时异常，又称为非运行时异常，这样的异常必须在编程时进行处理，
            否则就会编译不通过。除RuntimeException异常类及其子类以外的Exception异常类及其子类都
            是检查时异常类。
        Java源文件也能编译通过，RuntimeException异常类及其下面的子类均为运行时异常
三、异常捕获
    java中对异常的处理有如下两种方式：
            1.通过try、catch和finally关键字捕获异常
            2.通过throw或throws关键字抛出异常
    捕获异常语法结构
        try｛
              //可能抛出异常的语句块
        }catch(SomeException1 e){ // SomeException1特指某些异常 
             //当捕获到SomeException1类型的异常时执行的语句块
        } catch( SomeException2 e){
             //当捕获到SomeException2类型的异常时执行的语句块
        }finally｛
             //无论是否发生异常都会执行的代码
        }
        try语句块中的代码可能会引发多种类型的异常，当引发异常时，会按顺序看每个catch语句，
        并执行第一个与异常类型匹配的语句，其后catch语句被忽略，且在捕获异常的时候，应按照
        “从小到大”的顺序捕获异常，即先子类后父类。
    
    finally关键字
        java异常在try/catch块后加入finally块，确保无论是否发生异常情况finally中的代码总能
        被执行
        final、finally和finalize区别：
            final-修饰符（关键字），修饰的类不能被继承，修饰的方法不能被重写，修饰的变量为
            常量
            finally-在异常处理时提供finally块来执行任何清楚的操作。
            finalize-方法名，finalize()方法在垃圾收集器将对象从内存中清除之前做必要的清理
            工作，如下代码：
                    class Student {
                        @Override
                        protected void finalize() throws Throwable {
                            super.finalize();
                            System.out.println("对象从内存中清除之前执行");
                        }
                    }
                    public class Test {
                        public static void main(String[] args) {
                            new Student();
                            System.gc();//执行该代码，垃圾收集器将回收未使用的内存空间。
                        }
                    }
    抛出异常：
        throw关键字：
            
            throw用于抛出具体异常的对象，一般用于方法中，当所写的代码因不满足某些条件致
            使程序无法运行时可以借助throw抛出一个异常对象提醒程序员。(如果用普通的System.out.println，
            是因为普通的输出仅仅是一句话，无法向抛出异常时那样能准确地定位到代码出错的位置)
            
            throw关键字一般用在方法中，也可以用在具体代码中，但如果代码块中抛出的异常对
            象是由检查时异常创建的，则必须使用try-catch进行处理。
            
            抛出对象：
                1.抛给自己：抛出异常后直接用try-catch处理，代码如下
                        try{
                            throw new UnsupportedOperateException("出现异常");
                        }catch(UnsupportedOperateException e){
                            System.out.println("出现异常！");
                        }
                2.抛给方法的调用者，代码如下
                    public class PrintUtil {

                        public  static void printAge(int age) throws PrintException {
                        //此处由于该方法使用throw抛出的是由检查时异常创建的对象并且throw后没有自行处理，
                                        所以这里必须要使用throws抛出创建该异常的异常类；此处也可以throws 
                            if (age >= 150 || age <= 0) {
                                throw new PrintException("打印失败，请输入0~150之间的数");
                            } else {
                                System.out.println("年龄为：" + age);
                            }
                        }
                    }
                    或
                    public class PrintUtil {

                        public  static void printAge(int age){
                        //此处该方法抛出的是运行时异常，可以直接抛出 
                            if (age >= 150 || age <= 0) {
                                throw new UnsupportedOperateException("打印失败，请输入0~150之间的数");
                            } else {
                                System.out.println("年龄为：" + age);
                            }
                        }
                    }
            解决方法：
                    1.方法调用者使用try-catch处理该异常（推荐)
                        public static void main(String [] args){
                            
                            try{
                                new PrintUtil().printAge(1000)
                            }catch(UnsupportedOperateException e){
                                e.printStackTrace();
                            }
                        }
                    2.继续上抛对象：方法调用者继续上抛该异常，由于方法抛出的是运行时异常类创建的对象，
                    所以可以如下这样做；如果抛出由检查时异常类创建的对象，则这种处理方式必须使用throws
                    关键字抛出创建该对象的异常类或其父类
                    
                        public static void main(String [] args){
                                new PrintUtil().printAge(1000);
                        }
            作用：使用throw抛出异常对象如果没有try-catch捕获该异常对象，则该抛出异常对象语句执行后其所
            在方法结束执行

        throws关键字：
        
                用于声明方法可能抛出的异常，其后为异常类，可以有多个，异常类之间用英文逗号间隔。
                
                使用情况：
                        1.当方法体中的throw关键字抛出由检查时异常创建的对象时，如果该异常对象在抛出的同时已经
                    通过try-catch进行了处理，则可以不使用throws，否则必须使用throws抛出创建该对象的异常
                    类或其父类。
                        2.所调用的方法抛出了检查时异常时，如果该方法在调用的同时已经通过了try-catch进行了处理，
                    则可以不使用throws继续上抛该异常，否则必须使用throws才能上抛该异常，此事上抛的异常类可
                    以是调用方法时方法抛出的异常类也可以是其父类。同样的，如果方法中的异常已经通过try-catch
                    进行了捕获则无需再使用throws上抛该异常了，否则即使上抛也是无效的。
                        3.如果方法中的代码或者方法中所调用的代码没有使用throw抛出异常类对象，则无需使用throws，
                        否则该throws所抛出的异常类无效：即使用throws则其方法中的代码一定存在使用throw抛出异常
                        对象的代码。
        
        throw和throws的区别：
            1.throw抛出的是具体的对象，throws抛出的是抽象的异常类；
            2.使用的位置不同：throw一般用在方法体中，也可以用在代码块中，但是如果抛出的是检查时异常类创建的对象，
            则必须使用try-catch自行处理;throws只能用在方法声明括号后面；
        
        自定义异常类：
            作用：javaAPI提供的已有异常类无法准确表述当前发生的异常问题，这时就需要创建自定义的异常。
            做法：
                1.创建继承Exception或其子类的自定义类;
                2.自定义异常类调用父类构造函数（通常是含有一个String类型参数的构造函数）