本文共 5024 字，大约阅读时间需要 16 分钟。

Java 异常

异常情形：

• 概念：指程序在运行过程中阻止当前方法或作用域继续执行的问题（意外的情况）；
• 异常与错误
  • 错误：很难处理（如内存溢出）；不能通过异常处理来解决，错误无法控制，程序肯定中断
  • 异常：程序中发生不正常事件流，通过处理程序依然可以运行下去。

异常的体系：

• Throwable：是Java语言中所有错误或异常的超类。有两个子类：Error和Exception。
  • Error（错误）：用与指示合理的应用程序不应该试图捕获的严重问题
  • Exception（异常）：所有异常类的父类，是可以捕获并处理的；异常分为运行期异常与非运行期异常（通常称为编译期异常）。

异常(Exception)：

• 运行期异常（RuntimeException）:程序运行时抛出的异常，其子类都是运行期异常。

  • ArithmeticException 数学异常
  • NullPointerException 空指针异常
  • IndexOutOfBandsException 下标越界
  • ClassCastException 类型强制转换异常
  • IllegalArgumentException 参数异常

    public class ExcptionTest {    public  void test(){        System.out.println("====运行前====");        int a=10/0;        System.out.println("====运行后====");      }    public static void main(String[] args) {            ExcptionTest et= new ExcptionTest();        et.test();    }}

• 检测异常（CheckedException不存在此类）：非运行期的异常

  • IOException
  • SQLException

• RuntimeException与CheckedException

  • RuntimeException不会引起编译报错，不需要强制处理；
  • CheckedException会引起编译报错，需要强制处理（需抛出才能捕获），不捕获将不能编译；

    public class RuntimeExceptionDemo {    public static void main(String[] args) /*抛出异常throws IOException*/ {        //运行时异常，不会引起编译错误,不需要强制处理        try{            String a = null;            System.out.println(a.length());        }catch(NullPointerException e){            e.printStackTrace();        }        //checkedException异常，会引起编译异常，需要强制处理        try {            throw new IOException();        } catch (Exception e) {            e.printStackTrace();        }    }}

try、catch、finally的使用：

• try：检测不安全代码块（发现异常。一个try块中可以存在多个异常，但检测到异常就会结束try块）；
• catch：异常处理代码（没有catch异常时，JVM会捕获异常终止运行）；
• finally：不管出现或不出现异常都会执行的代码；
• 其中catch块和finally块可省略，但try块不能；
• 可以有多个catch块；
• 捕获异常，父类异常的catch块在子类catch块之后；
• 可以catch任何异常
  • catch CheckedException异常时，try块需抛出异常（最后一行抛出）；

• catch和finally中有编译期异常需try catch处理 或throws方法抛出异常；

  public class TryCatchFinally {    public static void main(String[] args) {        try {            String str = null;            str.length();            int i = 10/0;            System.out.println("这是try");            //CheckedXception需要抛出才能catch            throw new IOException();            System.out.println("这是catch");        }        //当多个 catch捕捉 Exception异常时需要注意父类在子类后catch        catch(NullPointerException e){            System.out.println("这是catch");                try {                throw new SQLException();            } catch (SQLException e1) {                // TODO Auto-generated catch block                e1.printStackTrace();            }        }catch(Exception e){            System.out.println("这是catch");        }        finally {            System.out.println("这是finally");        }    }}

finally与return：

　　return不能阻止finally的执行（先finally在return），异常也不能阻止finally的执行，System.exit(0)会终止finally;

public class Test {        public static void main(String[] args) {            try{                System.out.println("try 阻止世界的运作");                //System.exit(0);                System.out.println(10/0);                //return ;            }catch(Exception e){                System.out.println("catch 异常");                return ;            }            //finally不受return和异常影响            finally{
  //占时知道System.exit();能结束                System.out.println("你不能阻止世界的运作");            }            System.out.println("你很吊啊return");        }    }

throw、throws与层层抛出异常：

• throw可以主动抛出异常（注意异常强制处理问题）；
• 方法标签throws抛出异常，调用抛出异常方法需强制处理异常或继续往上抛，可以抛出多个异常用逗号隔开；

• 层层抛出异常：catch中，再次用throw抛出异常；

  public class ThrowAndThrows {
           public static void main(String[] args) {        try{            testThrows();        }catch(IOException e){            e.getStackTrace();        }catch(NullPointerException e){            e.printStackTrace();        }    }    //throws抛出多个异常    public static void testThrows() throws IOException,NullPointerException{        throwsShow();    }    public static void throwsShow() throws IOException{        throw new IOException("编译异常");     }    public static void throwShow(){        try{            throw new IOException();        }catch(IOException e){            e.getStackTrace();        }    }}

自定义异常：

• 自定义类继承Exception类;
• 添加构造方法用super调父类对应构造器；
• 在某个方法抛出该异常；

• 捕获该异常；

  public class CustomException extends Exception{
           //自定义异常类继承Exception类，只有构造方法    public CustomException(){}    //创建构造器，用super调用父类对应构造器    public CustomException(String message) {        super(message);    }}public class Test {
           public static void main(String[] args) {        //捕获自定义异常        try {            showMyException();        } catch (CustomException e) {            e.printStackTrace();        }    }    public static void showMyException() throws CustomException{        throw new CustomException("自定义异常");    }}

  结果：

  com.chinasofti.se.exception.CustomException.CustomException: 自定义异常at com.chinasofti.se.exception.CustomException.Test.showMyException(Test.java:18)at com.chinasofti.se.exception.CustomException.Test.main(Test.java:9)

异常的使用误区

• 尽可能减小try块；
• 保证所有资源都被正确释放，正确运用finally关键字；
• catch语句应当尽量指定具体的异常类型，而不应该指定涵盖范围太广的Exception类；不要一个Exception试图处理所有可能出现的异常；
• 既然捕获了异常，就要对它进行适当的处理。不要捕获异常之后不予理睬（丢弃）；
• 在异常处理模块中提供适量的错误原因信息，组织错误信息使其易于理解和阅读；
• 不要在finally块中处理返回值；
• 不要在构造函数抛出异常。

转载地址：https://blog.csdn.net/qq_29593573/article/details/72902823 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！