🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈
 
🍂个人博客首页： KJ.JK
 
欢迎大家点赞👍收藏💖评论💬关注🔒
 
💖源码获取 | 💻学习交流 | 🤝商务合作 | 💨私信作者

💨更多相关知识👇

💖JavaEE中的静态方法定义、方法重载要求、return作用详解

💖List接口的常用方法，精华总结

💖JavaEE里面的所有内部类详细介绍与使用

💖ArrayList集合中的常用成员方法

💖Java中String的split切割字符串方法详解

💖String中的replace的四个方法

💖JavaEE中的Stream流的常用方法

💖JavaEE中的Stream流知识点使用，精华总结，一文直接上手

💖JavaWeb中的过滤器（Filter）和监听器（Listener）区别

💖JavaEE中史上最全String类入门介绍文章，学习StringAPI这一篇即可

🐬【JavaEE进阶序列 | 从小白到工程师】JavaEE中的异常处理与解决方案详解上篇 🐬

一、查看异常信息

🍒public void printStackTrace()

// public void printStackTrace() :   把异常的详细信息显示在控制台
        try {
            String s=null;
            System.out.println(s.length());
        } catch (NullPointerException e) {


            e.printStackTrace();    //将异常信息详细信息显示在控制台,给程序员定位异常看的信息

        }

        System.out.println("结束");

🍒public String getMessage()

//public String getMessage() :   返回此异常的简单描述信息
        try {
            String s="A";
            System.out.println(s.charAt(3));
        } catch (StringIndexOutOfBoundsException e) {

              //可以记录错误信息到文件中
            //getMessage():返回此异常的简单描述信息,可以记录错误信息到文件中
            String message = e.getMessage();   //String index out of range: 3
            System.out.println(message);

        }
        System.out.println("结束");

🍒public String toString()

//public String toString(): 返回此异常的类型和简单描述信息

    try {
            String s="A";
            System.out.println(s.charAt(3));
        } catch (StringIndexOutOfBoundsException e) {

            String s = e.toString();
            System.out.println(s);
            //java.lang.StringIndexOutOfBoundsException: String index out of range: 3

        }
        System.out.println("结束");

二、异常处理 — throws声明异常

1、为什么需要throws？

           *当一个方法内部产生异常，而方法无法做出处理时，可以在"该方法的头部声明这个异常"，
               
           "把异常交给调用者进行处理" （相当于上报异常，做免责声明）

2、throws的格式

       
       格式:
              修饰符 返回值类型 方法名(参数列表) throws 异常类名1,异常类名2{
	
                }

       范例:
             public  static Date stringData(String date) throws ParseException {
                 
                }

//注意: throws关键字可以声明抛出多个异常，多个异常使用逗号隔开

⭐代码演示

public class Demo {
    public static void main(String[] args) throws ParseException {
     
        Date date = stringData("2020-10-10");
        System.out.println(date);


    }


    /*
         异常处理:抛出异常

          在方法的定义上,使用throws 抛出异常
          目的:当程序中出现异常时,可以告知调用者,让调用者处理
     */

    public  static Date stringData(String date) throws ParseException {

        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");

        Date d = sf.parse(date);

        return  d;


    }
}

3、throws的使用场景

    throws 声明抛出异常的思路是:
    
            当前方法不知道如何处理这种类型的异常，该异常应该由上一级调用者处理，如果调用者也不知道如何处理，那就继续向上声明抛出异常，以此类推直到main方法

            如果 main 方法也不知道如何处理这种类型的异常，也可以使用 throws 声明抛出异常，该异常将交给 JVM 进行默认处理

4、throws的使用注意

       1.当进行方法重写时，子类重写的方法throws的异常的范围不能大于父类方法的异常范围
       
       2.父类方法没有声明抛出编译时异常，子类重写的方法也不能抛出编译时异常
       
       3.建议重写的方法声明的异常和父类方法保持相同即可

🌟案例1演示（子类的异常不能大于父类的异常）

class   Father{
    public  void test() throws  ParseException{

    }
}


class  son extends  Father{

    @Override


    //子类的异常不能大于父类的异常

    //子类的异常可以不写

    public  void test() throws Exception{

    }
}

🌟案例2演示（父类没有抛出异常,子类不能抛出异常）

class  Father{
    public void test(){

    }
}


class  son extends  Father{

    @Override

    //如果父类没有抛出异常,子类不能抛出异常
    //要求子类的方法,异常的情况应该更少
    public  void test() throws  ParseException{

    }
}

三、两种处理异常方式的小结

声明throws:

    *对可能出现异常的方法进行异常声明
    
    *告知调用者某个方法可能有问题，方法自身没有进行处理，而是让调用者去处理
   
   
捕获try…catch:

     * 捕获并处理可能出现的异常
     
     * 好处:能让代码继续往下运行

   

四、throw关键字

🍊throw关键字可以做什么？

            Java中提供了throw关键字，可以在程序运行过程中，抛出某种特定的异常
      
//throw是用来制造异常的               
//注意:throw异常以后，后面的代码将停止执行               

🍊throw的格式

               格式:
                       throw new 异常类名();
               范例:    
                       throw  new Un18Exception("非法年龄异常");

🍊产生异常的意义

       * 在方法中，当传递的参数有误，程序没有运行下去的意义时，可以直接抛出异常，结束方法
       
       * 告知调用者方法中出现了问题，让调用者修改代码逻辑

五、throws 和 throw 的区别

throws
    * 是异常的处理方式之一，在方法定义时进行声明 
    
    * 是在方法的定义上,向上抛出异常给调用者处理(异常的提示)
 
    
--------------------------------------------------------------------------------------------
    
throw
   * 是产生一个异常的关键字，用在方法体内部
   
   * throw是在方法中,"产生异常",一旦执行,方法会停止,相当于return
  
   * throw异常以后，后面的代码将停止执行

🔥系列热门专栏🔥：
 
⚡《JavaEE进阶序列 | 从小白到工程师》系列文章⚡
 
⚡《JavaEE项目实战》系列文章⚡
 
⚡《JavaSwing项目合集》系列文章⚡
 
⚡《数据分析中的pandas》系列文章⚡

六、自定义异常

1、为什么需要自定义异常？

             * JDK提供的异常虽然比较多，但是不一定符合我们的需求
                 
               此时我们可以根据自己的业务来定义异常类。例如年龄负数问题，考试成绩负数问题
       
//自定义异常存在的意义：就是为了让控制台的报错信息更加的见名之意   
// try catch 也适用自定义异常

2、自定义异常的步骤

                   * 定义异常类
                 
                   * 写继承关系
                 
                   * 空参构造
                 
                   * 带参构造
                      
//产生自定义异常方式:throw new 自定义异常(“异常信息”);
//如果throw的是"编译时异常"，需要在方法定义处使用"throws声明"

🌟 案例1（自定义编译异常）

public class Un18Exception extends  Exception{

    //无参构造方法
    public  Un18Exception(){
    }


    //带参构造方法
    public  Un18Exception(String message){
        super(message);
    }

}

public class Demo {


    public static void main(String[] args) {

        try {
            register();
        } catch (Un18Exception e) {
            e.printStackTrace();
        }


    }


    //编译时异常:产生时,一定要处理(通常throws抛出)

    public  static  void register() throws Un18Exception{  //告诉调用者,该方法可能有异常,需要调用者去处理
        Scanner rd=new Scanner(System.in);
        int age=rd.nextInt();

        if(age>=18){
            System.out.println("注册成功");
        }else {
            //产生异常,告诉用户去处理
//            throw 异常对象

            throw  new Un18Exception("非法年龄异常"); //制造异常,用在方法内部,
                                                   // 作用类似return

//            throw  new Exception("非法年龄异常");
        }
    }

🌟 案例2（自定义运行时异常）

//自定义运行时异常
public class Un18RuntimeException extends  RuntimeException{

    //描述异常的信息

    private  String message;

    //无参构造方法
    public  Un18RuntimeException(){
    }


    //带参构造方法
    public  Un18RuntimeException(String message){
        super(message);
    }


    public void setMessage(String message) {
        this.message = message;
    }


}

import java.util.Scanner;

public class Demo {


    public static void main(String[] args) {


        register2();


    }


    /*   运行时异常：
             继承自RuntimeException的异常。
             编译期间无需处理，可以通过优化代码逻辑来解决
             所以不用 throws都可以

             运行时异常,产生时,不需要去声明异常信息
    */
    public  static  void register2() {

        Scanner rd=new Scanner(System.in);
        int age=rd.nextInt();

        if(age>=18){
            System.out.println("注册成功");
        }else {
            //产生异常,告诉用户去处理
//            throw 异常对象

            throw  new Un18RuntimeException("非法年龄异常"); //制造异常,用在方法内部,
            // 作用类似return



//            throw  new Exception("非法年龄异常");
        }
    }

}

七、异常总结

 1.异常的分类："编译时异常" 和 "运行时异常" 
       *编译时异常:
                  继承自Exception的异常，需要显式处理
       *运行时异常:
                  继承自RuntimeException的异常，无需显式处理

 2.异常的处理方式: "throws" 和 "try-catch"
     
       * throws抛出的意义:
                           让方法停止并告诉调用者这里出现了问题
                             
       * try-catch捕获的意义:
                           让程序可以继续往下执行

  3. 异常处理通常都是针对编译时异常，对于运行时异常，需要强化代码逻辑避免发生

  4. 自定义异常的意义: 
                        让程序的提示报错更加的见名知意

  5. 产生异常对象:
                        throw new 异常类构造器();

作者：KJ.JK

文章对你有所帮助的话，欢迎给个赞或者 star，你的支持是对作者最大的鼓励，不足之处可以在评论区多多指正，交流学习