Java的异常机制

异常机制

• Java把异常当作对象来处理，并定义一个基类 java.lang.Throwable作为所有异常的超类（最顶层的类）。

• 在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。

• Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。

• Java虚拟机运行错误（Virtual Machine Error），当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

• 还有发生在虚拟机试图执行应用时类定义错误（NoClassDefFoundError）、链接错误（LinkageError），这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。

异常处理机制

• 异常捕获：try、throw、throws

• 异常处理：catch、finally

package com.exception;
​
public class Test{
    public static void main(String[] args){
        int a = 1;
        int b = 0;
        
        try{
            System.out.println(a/b);
        }catch(ArithmeticException e){
            System.out.println("variabel should not be zero");
        }catch(Error e){
            //和 if else 一样，执行一个就不再执行其他的。
            System.out.println("Error");
        }catch(Exception e){
            System.out.println("Exception");
        }catch(Throwable t){
            System.out.println("Throwable");
        }finally{//无论如何，终将执行。
            System.out.println("finally");
        }
    }
}

• try 和 catch 后面可以不要finally，以后学的 IO 流，就是与资源相关的东西，出现异常要把它关闭，相关代码就放 finally 里面。

• 假设要捕获多个异常，需要按异常从小到大顺序安排catch位置。

• Ctrl + Alt + T 是try、catch、finally三个代码块生成的快捷键

package com.exception;
​
public class Test{
    public static void main(String[] args){
        int a = 1;
        int b = 0;
        //Ctrl + Alt + T
        try{
            System.out.println(a/b);
        }catch(Exception e){
            e.printStackTrace(); //打印错误的栈信息
            //System.exit(status:0/1/2/3/4)
        }finally{
            //除非在catch内直接退出，不然都要执行。
        }
    }
}

• 主动抛出异常

package com.exception;
​
public class Test{
    public static void main(String[] args){
        int a = 1;
        int b = 0;
        //Ctrl + Alt + T
        try{
            if (b == 0){ //throw throws
                throw new ArithmeticException();
                //主动抛出异常，一般在方法中使用。
            }
            System.out.println(a/b);
        }catch(Exception e){
            
        }finally{
            
        }
    }
}

• 在方法上和方法内抛出异常

package com.exception;
​
public class Test{
    public static void main(String[] args){
        //一般来说需要捕获抛出的异常，在catch里给它处理了。
        try{
            new Test().test(1, 0);
        }catch (ArithmeticException e){
            e.printStackTrace();
        }
    }
    
    //假设这个方法中处理不了这个异常，就在方法上抛出异常。
    public void test(int a, int b) throws ArithmeticException{
        if(b == 0){
            throw new ArithmeticException();
            //主动抛出异常就是在方法里用
        }
    }
}

自定义异常

• 使用 Java 内置的异常类可以描述在编程时出现的大部分异常情况，除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。

• 在程序中自定义异常类，大体可分为以下几个步骤：

  • 创建自定义异常类

  • 在方法中通过 throw 关键字抛出异常对象

  • 如果在当前抛出异常的方法中处理异常，可以使用 try - catch 语句捕获并处理；否则在方法的声明处通过 throws 关键字指明要抛出给方法调用者的异常，继续进行下一步操作。

  • 在出现异常方法的调用者中捕获并处理异常

package com.exception.demo;
​
//自定义异常类
public class MyException extends Exception{
    //传递数字大于10就抛出个异常
    private int detail;
    public MyException(int a){
        this.detail = a;
    }
    //toString 异常的打印信息
    @Override
    public String toString(){
        return "MyException{" + "detail = " + detail + '}';
    }
}

//测试类
package com.exception.demo;
​
public class Test{
    //可能会存在异常的方法，不在函数内捕获就选择内抛外也抛，异常留给调用这个方法的对象来捕获它。
    static void test(int a) throws MyException{
        System.out.println("传递的参数为：")
        if(a > 10){
            throw new MyException(a);//抛出
        }
        System.out.println("ok");
    }
    public static void main(String[] args){
        try{
            test(11);
        }catch(MyException e){
            //e.printStackTrace();
            Sytem.out.println("MyException => " + e);
        }
    }
}

• 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理。

• 在多重 catch 块后面，可以在最后加一个最大的catch (Exception)来处理可能会被遗漏的异常对于不确定的代码，也可以加上try-catch，处理潜在的异常。

• 对于不确定的代码，也可以加上try-catch，处理潜在的异常。

• 尽量去处理异常，切忌只是简单地调用print Stack Trace()去打印输出。

• 具体如何处理异常，要根据不同的业务需求和异常类型去决定。

• 尽量添加finally语句块去释放占用的资源

• IDEA里假设有异常，会在关键字下出现红色波浪线，这时候按下 ALT + ENTER 键，它会自动提示你一些东西该怎么处理，极为万能的一个组合键。