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);

    }

}

 import java.util.Scanner;

 /**

  * 利用异常，模拟注册功能

  */

 public class IsRegister {

     //1.数组保存已经注册的用户名（数据库）

     static String[] usename = {"赵", "王", "孙"};

     public static void main(String[] args) /*throws RegisterException*/ {

         //2.一般从前端获取数据源

         Scanner sc = new Scanner(System.in);

         System.out.println("请输入用户名: ");

         String name = sc.nextLine();

         checkUsename(name);

     }

     //3.定义一个方法对用户输入的数据进行判断

     public static void checkUsename(String name) /*throws RegisterException*/ {

         for (String usename : usename) {

             if(usename.equals(name)){

                 try {

                     throw new RegisterException("用户已注册"); //运行期异常，可以不用throws和try catch

                 } catch (RegisterException e) {

                     e.printStackTrace();

                     return;//结束

                 }

             }

         }

         //注册成功

         System.out.println("注册成功");

     }

 }

/*

//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);

    }

}

巴特西

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

最新文章

热门文章