Throwable -抛出异常类与自定义异常类

/*
    自定义异常类
        java提供的异常类，不够我们使用，需要自己定义一些异常类
     格式：
        public class XXXException extends Exception/runtimeException{
            添加一个空参数的构造方法
            添加一个带异常信息的构造方法
        }
      注：
        1.自定义异常类一般是Exception结尾，说明该类是一个异常类
        2.必须继承Exception/RuntimeException
 */
public class RegisterException extends Exception {
    //添加一个带空参数的异常
    public RegisterException() {
    }

    //查看异常源码可知，可以让父类的构造方法来解决异常信息
    public RegisterException(String message) {
        super(message);
    }

}

 1 import java.util.Scanner;
 2 
 3 /**
 4  * 利用异常，模拟注册功能
 5  */
 6 
 7 public class IsRegister {
 8     //1.数组保存已经注册的用户名（数据库）
 9     static String[] usename = {"赵", "王", "孙"};
10 
11     public static void main(String[] args) /*throws RegisterException*/ {
12         //2.一般从前端获取数据源
13         Scanner sc = new Scanner(System.in);
14         System.out.println("请输入用户名: ");
15         String name = sc.nextLine();
16         checkUsename(name);
17 
18     }
19     //3.定义一个方法对用户输入的数据进行判断
20     public static void checkUsename(String name) /*throws RegisterException*/ {
21         for (String usename : usename) {
22             if(usename.equals(name)){
23                 try {
24                     throw new RegisterException("用户已注册"); //运行期异常，可以不用throws和try catch
25                 } catch (RegisterException e) {
26                     e.printStackTrace();
27                     return;//结束
28                 }
29             }
30         }
31         //注册成功
32         System.out.println("注册成功");
33     }
34 }

/*
//Throwable所有异常的超类
      Exception -编译异常，可以throws或者try{}catch{}  -子类
      RuntimeException -运行异常，可以不处理，让JVM处理
      Error -无法处理，必须修改源代码，内存溢出，系统崩溃 -子类
  异常处理过程：方法里面异常，查看有没有异常处理逻辑，若没有
               ——把内容，原因，位置报告JVM——找到方法的调用者（main）
               ——查看有没有异常处理逻辑，若没有——返回给JVM，JVM控制台打印，并且中断程序

//运行时异常
  throw关键字
        作用：可以使用throw关键字在指定的方法中抛出指定的异常
             格式：throw new xxxException("异常产生的原因")
             注：1.throw关键字必须在方法的内部
                2.throw关键字new的必须是Exception或其子类对象
                3.throw关键字抛出指定的异常对象，我们必须处理这个对象
                    1.throw关键字后边创建的是RuntimeException或其子类对象，可以交给JVM（打印异常+中断程序）
                    2.throw关键字后边创建的是编译异常（写代码的时候），要么throws，要么try catch
工作中，必须对对方传递过来的方法进行合法化校验，不合法，则抛出异常的方式给到调用者

//编译异常
  throws关键字：异常处理的第一种方式，交给被人处理
        作用：
            当方法的内部抛出异常对象的时候，那么我们就必须处理这个异常对象
            throws将异常对象声明（内容，原因，位置）给调用者，自己不处理，最终会交付给JVM
        格式：
            修饰符 返回值类型 方法名（参数列表）throws XXXException，XXX，XXX{
                throw new XXXException("异常的原因")
            }
        注意：throws 后面的异常声明必须是Exception或其子类
              方法内部如果有多个异常对象，throws必须声明多个
              如果异常对象有子父类对象，直接声明父类异常即可
  此外，如一旦声明抛出异常的方法，就必须处理该异常，要么继续在调用对象throws声明异常，最后交给方法调用者最后交给JVM，中断
  要么try...catch自己处理（一般这种比较好）不中断

  try catch：异常处理的第二种方式，自己处理
        格式：try{
            可能异常的代码
        }catch(定义一个异常变量接受try中异常变量){
            异常处理逻辑，工作中会把信息记录进日志
        }
        ...
          catch(定义一个异常变量接受try中异常变量){
            异常处理逻辑，工作中会把信息记录进日志
        }
        注：try中可能有对个异常对象，所以需要多个catch来处理
            如果try中产生异常，就会执行catch的异常处理逻辑，继续执行之后的代码
            如果catch里的异常类有父子类关系，子类应该写在上边(二义性)，Exception所有的异常类


  finally
        格式：try{
            可能异常的代码
        }catch(定义一个异常变量接受try中异常变量){
            异常处理逻辑，工作中会把信息记录进日志
        }
        ...
          catch(定义一个异常变量接受try中异常变量){
            异常处理逻辑，工作中会把信息记录进日志
        }finally{
           无论代码是否出现异常，这里都会执行
        }
        注：finally不能单独使用，必须与try一起用，finally一般用于资源释放，无论程序是否有异常，均需要释放资源

*/

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.List;

public class Throwable {
    public static void main(String[] args) /*throws IOException*/ {
        //RuntimeException可以不用自己处理交给JVM
        //int[] num=new int[5];
        //getElement(num,6);

        //编译异常，需要自己处理，使用throws
        //readFile("c:\\b.txt");不会执行，因为上面的异常JVM让程序已经中断

        //使用try catch
        try {
            readFileC("c:\\b.txt");  //有可能出现异常的代码
        } catch (ArrayIndexOutOfBoundsException e) {//throws声明的什么异常，就用来生成对象来接收
            //异常处理逻辑
            /*
        Throwable类中定义了三个方法：
             String toString()    - 返回此 throwable 的详细消息字符串。
             StackTraceElement[] getStackTrace() - 提供编程访问由 printStackTrace() 输出的堆栈跟踪信息，JVM打印默认调用此方法
             String getMessage() -返回此 throwable 的简短描述。
           */
            System.out.println(e.toString());   //java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 3
            System.out.println(e.getMessage()); //Index 4 out of bounds for length 3
            System.out.println(e.getStackTrace()); //[Ljava.lang.StackTraceElement;@4e50df2e
        }finally {
            System.out.println("资源释放");  //finally无论是否异常，均执行
        }
        System.out.println("劳资没有中断，太强了");


    }


    public static void getElement(int[] arr, int index) {

        //运行期异常，可以不用自己处理
        if (index > 4 || index < 0) {
            throw new ArrayIndexOutOfBoundsException("数组索引有问题");  //ArrayIndexOutOfBoundsException运行期异常，交给JVM，不用自己throw
        }
        //在Objects里有个判断NullPointerException的方法可以判断 对象 是否为空，简化上述代码
        //格式Objects.requireNonNull(对象名);
        //另一个重载Objects.requireNonNull(对象名,"抛出的信息")

    }

    /*
    定义一个方法，对传递的文件路径合法化判断，使用throws
                由于FileNotFoundException extends IOException
                所以声明IOException即可
     */
    public static void readFile(String src) throws IOException {
        //抛出文件位置异常
        if (!src.equals("c:\\a.txt")) {
            throw new FileNotFoundException("文件位置不匹配");
        }
        //抛出文件后缀异常
        if (!src.endsWith(".txt")) {
            throw new IOException("文件位置不匹配");

        }
    }

    public static void readFileC(String src) {
        List<Integer> integers = List.of(1, 2, 3);
        integers.get(4);

    }
}