Java基础（八）异常处理

一、异常

　　异常是指程序在运行过程产生的不正常情况。语法错误不算异常。

1、异常体系

　　Throwable：Java语言中所有错误或异常的超类；Throwable 类的子类有两个：1、Error；2、Exception。

1、所有的异常类都是 java.lang.Exception 的子类，Exception相对来说，可以控制，可以处理。

2、Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。例如：JVM 内存溢出。

3、Error 用来指示运行时环境发生的错误。

4、通过看子类是Exception结尾还是Error结尾，来判断是Exception体系还是Error体系。

异常分类

运行时异常：RuntimeException 以及它子类的类型。

如果没有处理（抛出或者try-catch），编译不会报错。

非运行时异常：Exception 以及它的子类，但是除去RuntimeException和它的子类。

如果没有处理（抛出或者try-catch），编译的时候报错。

2、异常处理

　　异常处理有两种方式：

1、自己处理try -catch

　　写在可能发生异常代码的地方，如果出现异常，产生异常，就会被捕捉到，捕捉的异常信息放到异常类型的变量里面去；这样就可以进行处理这个异常。

　　如果没有异常出现，就不捕捉，就往下面继续执行走。

语法结构：

    try{
    //可能出现异常
    }catch(异常类型 变量名){
    //处理异常代码
}

处理异常代码：

1、把错误提示给用户。直接调用 printStackTract方法就打印异常信息。

2、把异常信息，保存到日志文件，便于查看。

2、自己不处理，向外抛出

　　抛出到JVM，还可能在实际开发过程，遇到方法调用方法，调用很多层，那种抛出，就像上一层调用者进行抛出。

throws 和 throw的区别：

throws 表示向外抛出异常，位置：方法的(){}之间，特点：后面跟多个异常。

throw 产生一个异常对象，位置：方法里面。特点： 后面跟一个异常对象，相等于return的效果。

 public class ThrowsDemo {
     /**
      * 计算两个整数相除
      * @param a
      * @param b
      * @throws Exception
      */
     public void div(int a, int b) throws Exception {  // 抛出异常
         System.out.println(a / b);
     }

     /**
     * 测试div
     */
     @Test
     public void testDiv() throws Exception {
         div(1, 0);  //打印异常：java.lang.ArithmeticException: / by zero
     }
 }

3、多异常处理

语句结构：

     try{
     //可能出现异常的代码。。。
     }catch(异常类型 变量名){
     // 处理异常的代码
     }catch(异常类型 变量名){
     // 处理异常的代码
     }catch(异常类型 变量名){
     // 处理异常的代码
  }

3、异常finally语句

除了上面两种扑捉异常结构以外，还有其他的结构，可以在最后面添加一个finally

语法结构:

    try{
    //可能出现异常的代码
    }catch(异常类型 e){
     //处理异常:
        //1 打印到控制台
        //2 保存到文件
        //3 还可能向外抛出新的异常
    }finally{
}

finally单词什么含义，表示最终的意思。

1、关闭流资源或者释放锁--线程。

2、如果在finally前面没有执行系统退出（system.exit(0)）的语句，此处的代码始终都会执行。

3、不要在此处放return语句来返回一个数据。

 public class ExceptionTest {
     /**
      * 测试出现异常时，程序的执行顺序
      */
     @Test
     public void test1(){
         try {
             System.out.println("------执行1------");
             System.out.println("------执行2------");
             System.out.println("------num------" + (1/0));  //出现异常之后，不执行后面代码，即不打印------执行3------
             System.out.println("------执行3------");
         } catch ( ArithmeticException e) {
             System.out.println("------catch1------");
             System.out.println("------catch2------");
             e.printStackTrace();  //打印异常信息 java.lang.ArithmeticException: / by zero
             System.out.println("------catch3------");
         } finally {  //不管是否有异常都要执行
             System.out.println("------finally1------");
             System.out.println("------finally2------");
             System.out.println("------finally3------");
         }
     }
 }

4、自定义异常

　　创建了一个异常类，需要模拟产生自定义异常的场景：

1、自定义一个异常类型，需要创建一个类继承Exception或者RuntimeException，覆写里面的两个构造方法。

2、模拟一种场景，创建一种自定义异常的对象，通过throw创建异常对象。

3、使用上面场景，抛出或者处理

1、自定义一个异常类型。

 /**
  * 自己定义异常对象
  */
 public class LoginUserException extends RuntimeException{
     public LoginUserException() {  //覆写构造方法
         super();
     }

     public LoginUserException(String message) {   //覆写构造方法
         super(message);
     }
 }　

2、使用throw产生异常对象LoginUserException。

 public class LoginUserTest {
     public String checkLogin(String username, String password){
         if (!(Objects.equals(username, "user"))){
             System.out.println("------执行1------");
             System.out.println("------执行2------");
             System.out.println("------执行3------");
             throw new LoginUserException("name is wrong");  //自定义异常信息，throw的用法，产生一个异常对象LoginUserException
         }
         return "返回结果";
     }

 }

3、测试异常：

 public class ExceptionTest {
     /**
      * 测试自定义异常
      */
     @Test
     public void testCheckLogin(){
         LoginUserTest loginUserTest = new LoginUserTest();
         String s = loginUserTest.checkLogin("user1", "");
         System.out.println("----s:" + s);   //打印异常：exception.LoginUserException: name is wrong
     }
 }