Java学习记录之异常

异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。
在java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出一个异常对象。java处理异常的方式就是中断处理。
注意：异常指的并不是语法错误。语法错了，编译不通过，不会产生字节码文件，根本不能运行

异常的根类是：java.lang.Throwable 其下有两个子类：java.lang.Error 与java.lang.Exception 平时所说的异常指：java.lang.Exception
Error:指严重错误，无法通过处理的错误，必须修改源代码才能处理
Exception:指异常，异常产生后，可通过抛出异常、try catch等方法来处理掉异常，不必更改源代码

下面通过一张图来介绍ArrayIndexOutOfBoundException产生时的处理历程：

Throwable中的常用方法;
1.public void printStackTrace() :打印异常的详细信息；包含了异常的类型，异常的原因，还包括异常出现的位置，在开发和调试阶段，都得使用printStackTrace()
2.public String getMessage()：获取发生异常得原因；提供给用户得时候，就提示错误原因
出现异常不要紧张，把异常得简单类名，拷贝到API中去查

异常的分类
异常(Exception)得分类：
1.编译时期异常:checked异常。在编译时期，就会检查，如果没有处理异常，则编译失败
2.运行时期异常:runtime异常。在运行时期，检查异常，在编译时期不会出现异常提示

异常的处理
java异常处理的五个关键字：try 、catch、finally、throw、throws
一、抛出异常
在编写程序时，我们必须要考虑程序出现问题的情况，比如，在定义方法时，方法需要接收参数，那么，当调用方法使用接收的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时就需要使用抛出异常的方式来告诉调用者。
在java中，提供一个throw关键字，它用来抛出一个指定的异常对象
格式：
throw new 异常类名(参数)；

tips：
throw 关键字后面创建的是RuntimeException或者是RuntimeException的子类对象，我们可以不处理，默认交给JVM处理(中断程序，打印异常)。
throw关键字后面创建的是编译异常(checked异常，也就是写代码时候报出的异常)，我们就必须处理这个异常，要么throws,要么try…catch

public class ThrowDDemo{
   public static void main(String[] args){
      //创建一个数组
      int arr[] = {2,4,52,1};
      //根据索引找对应的元素
      int index=4;
      int element = getElement(arr,index);
   }
   public static int getElement(int[] arr,int index){
      //判断索引是否越界
      if(index<0||index>arr.length-1){
            /*
              判断条件如果满足，当执行完throw抛出异常对象后，方法已经无法继续运算。
              这时就会结束当前方法的执行，并将异常告知给调用者，这时就需要通过异常来解决
            */
            throw new ArrayIndexOutOfBoundsException("索引数值越界异常")；
      }
      //判断arr是否为空
      if(arr==0){
         throw new NullPointerException("传递的数组的值是null")；
      }
      int element = arr[index];
      return element;
   }
}

二、声明异常throws
声明异常：将问题标识出来，报给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。
关键字throws运用于方法声明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常(抛出异常)
格式：
修饰符 返回值类型 方法名(参数) throws 异常类名1，异常类名2…{ }

tips:
1.throws关键字后面声明的异常必须是Exception或者Exception的子类
2.方法内部如果抛出了多个异常对象，那么throws后面必须也声明多个异常。
如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可
3.调用一个声明抛出异常的方法，我们就必须处理声明的异常，要么继续使用throws声明抛出，交给方法的调用者，最终交给JVM；要么try…catch自己处理异常

public class ThrowsDemo{
    public static void main(String[] args) throws FileNotFoundException{
       read("a.txt");
    }
    //如果定义功能时有问题发生需要报告给调用者。可以通过在方法上使用throws关键字进行声明
    public static void read(String path) throws FileNotFoundException{
       if(!path.equals("a.txt")){//如果不是a.txt这个文件
       //假设不是a.txt文件，认为该文件是不存在的 是一个错误 也就是异常  throw出去
       throw new FileNotFoundException("文件不存在")；
        }
    }
}

三、捕获异常try…catch
格式：
try{
编写可能会出现异常的代码
}catch(异常类型 e){
处理异常的代码
//记录日志/打印异常消息/继续抛出异常
}

注意：try和catch都不能单独使用，必须连用
tips:
1.try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常
2.如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try…catch之后的代码；如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，就继续执行try…catch之后的代码

public class TryCatchDemo{
   public static void main(String[] args){
        try{//当异常产生时，必须有处理方式，要么捕获，要么声明
             read("b.txt");
        }catch(FileNotFoundException e){//
           //try中抛出的是什么异常，在括号中就定义什么异常类型
           System.out.println(e);
        }
   //我们当前的这个方法中 有异常有编译期异常
   public static void read(String path) throws FileNotFoundException{
      if(!path.equals("a.txt")){
           throw new FileNotFoundException;
      }
   }
   /*
     如果传递的文件不是.txt结尾
     那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
   */
   public static void readFile(String fileName) throws IOException{
      if(!fileName.endsWith(".txt")){
          throw new IOException("文件的后缀名不对")；
       }
   }
   }
}

finally代码块
finally:有些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
例如：当我们在try语句块中打开了一些物理资源(硬盘文件/网络连接/数据库连接等)，我们都得在使用完之后，最终关闭打开的资源
finally的语法：
try…catch…finally

注意：finally不能单独使用

public class TryCatchDemo4{
    public static void main(String[] args){
       try{
           read("a.txt");
       }catch(FileNotFoundException e){
         //抓取到的是编译期异常  抛出去的是运行期
         throw new RuntimeException(e);
       }finally{
          System.out.println("不管程序是否发生异常，这里都将执行")；
       }

     //下面的方法中 有异常 有编译期异常
     public static void read(String path) throws FileNotFoundException{
        if(!path.equals("a.txt")){
           throw new FileNotFoundException("文件不存在")；
        }
     }
    }
}

当只有在try或者catch中调用退出JVM的相关方法，此时finally才不会执行，否则finall永远会执行。

异常的注意对象
多个异常使用捕获又该如何处理呢?
1.多个异常分别处理
2.多个异常一次捕获，多次处理
3.多个异常一次捕获一次处理

public class Demo5Exception{
   public static void main(String[] args){
      //1.多个异常分别处理
      try{
        int[] arr = {1,2,3};
        System.out.println(arr[3]);//ArrayIndexOutOfBoundsException:3
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println(e);
      }
      try{
          List<Integer> list = List.of(1,2,3);
          System.out.println(list.get(3));//IndexOutOfBoundsException
      }catch(IndexOutOfBoundsException e){
          System.out.println(e);;
      }
      System.out.println("后续代码");

      /*
      2.多个异常一次捕获，多次处理
      一个try多个catch注意事项;
         *catch里面定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上面，
         否则就会出错*
         ArrayIndexOutOfBoundsException extends IndexOutOfBoundsExecption
      */
      try{
         int[] arr = {1,2,3};
         //当System.out.println(arr[3])执行时就会报出异常，程序就会中断不在往下执行了，也就是不会执行List<Integer> list = List.of(1,2,3);当把异常解决了才会执行
         System.out.println(arr[3]);//ArrayIndexOutOfBoundsException:3
         List<Integer> list = List.of(1,2,3);
         System.out.println(list.get(3));//IndexOutOfBoundsException
      }catch(ArrayIndexOutOfBoundsException e){
           System.out.println(e);
      }catch(IndexOutOfBoundsException e){
           System.out.println(e);
      }
   }
}

自定义异常
在Java中总是有些异常情况是SUN没有定义好的，此时我们根据自己的业务的异常情况来定义异常类。
如何定义：
1.自定义一个编译期异常：自定义类 并继承于java.lang.Exception
2.自定义一个运行期的异常：自定义类 并继承于java.lang.RuntimeException
下面通过自定义一个登录异常类RegisterException:

//业务逻辑异常
public class RegisterException extends Exception{
    //空参构造
    public RegisterException(){
    }
    /*
      有参构造
      参数message 表示异常提示
    */
    public RegisterException(String message){
         super(message);//调用父类的构造方法
    }
}

//测试类
public class Demo{
  //模拟数据库中已存在的账号
  private static String[] names = {"bill","hill","jill"};//定义在main函数上面，让其成为全局变量，可以被更大范围的使用
  public static void main(String[] args){
     //调用方法
     try{
         //可能出现异常的代码
         checkUsername("nill");
         System.out.println("注册成功");//如果没有异常就注册成功
     }catch(RegisterException e){
          //处理异常
          e.printStackTrace();
     }
  }
  //判断当前注册账号是否存在
  //因为是编译期异常，又想调用者去处理 所以声明该对象
  public static boolean checkUsername(String uname) throws RegisterException{
    for(String name : names){
       if(name.equals(uname)){
           throw new RegisterException("亲"+name+"已经被注册了！")；
       }
    }
    return true;//return ；有结束方法的作用，如果不想执行下面的代码，可直接return ；用来结束当前方法
  }
}