异常的处理

★夏夜微凉★

已于 2022-08-09 16:05:23 修改

阅读量700

点赞数 2

分类专栏： JavaSE基础部分文章标签： java 开发语言经验分享

于 2022-07-07 16:08:49 首次发布

本文链接：https://blog.csdn.net/qq_56501283/article/details/125658089

版权

JavaSE基础部分专栏收录该内容

33 篇文章 0 订阅

订阅专栏

前言：

异常的概念在之前的博客中有，本片博客中所说的异常都指的是都是Exception。上片博客中讲出现异常情况，一般处理方法有两种：一、遇到异常报出错误终止程序运行。二、在程序中预先设置好处理异常的的处理办法。我们这里主要讲第二种方法。

异常的处理

Java 编程语言使用异常处理机制为程序提供了错误处理的能力

程序中预先设置好

对付异

常的处理办法

Java 的异常处理是通过 5 个关键字来实现的：try 、 catch 、 finally 、 throw 、 throws

程序中预先设置好

对付

异常的处理办法

getMessage() 获取异常信息，返回字符串
printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void

1.捕获（try-catch）

概念：

/*
           try {
               可能出现异常的代码
           }catch(异常类型  e  用来接收抛出的异常对象){
                  捕获处理发生的异常
           }
            后续程序继续执行
         */

(1)try-catch

应用代码

public static void main(String[] args) {

        /*
           try {
               可能出现异常的代码
           }catch(异常类型  e  用来接收抛出的异常对象){
                  捕获处理发生的异常
           }
            后续程序继续执行
         */
            try {
                int a = 10;
                int b = 0;
                int c = a / b;
                System.out.println(c);
            }catch (Exception e){
                e.printStackTrace();//开发期间调试程序,打印异常信息
                //现实中使用一些日志组件将信息输出到日志文件中
                System.out.println("运算错误");
            }
        System.out.println("aaaaaaaaaaaaaaaa");

    }

（2）try-catch(嵌套)

public static void main(String[] args) {

        /*
           try {
               可能出现异常的代码
           }catch(异常类型  e  用来接收抛出的异常对象){
                  捕获处理发生的异常
           }
            后续程序继续执行
         */

            try {
                int a = 10;
                int b = 2;
                int c = a / b;
                System.out.println(c);

                try {
                    String s = null;
                    System.out.println(s.length());
                } catch (NullPointerException e) {
                    System.out.println("对象为空");
                }
                System.out.println("aaaaaaaaaaaa");
            }catch (ArithmeticException e){
                System.out.println("运算错误");
            }

        System.out.println("aaaaaaaaaaaaaaaa");

    }

注：嵌套怎么用要看具体问题具体情况

（3）try-catch(多catch)

 public static void main(String[] args) {

        /*
           try {
               可能出现异常的代码
           }catch(异常类型  e  用来接收抛出的异常对象){
                  捕获处理发生的异常
           }
            后续程序继续执行
         */

          try {
               "abc".charAt(4);

                int a = 10;
                int b = 2;
                int c = a / b;
                System.out.println(c);

               String s = "x";
               System.out.println(s.length());
                    
              System.out.println("aaaaaaaaaaaa");
            }catch (ArithmeticException e){
                System.out.println("运算错误");
            }catch (NullPointerException n){//捕获与本catch类型相同的异常
                System.out.println("对象为空");
            }catch (Exception e){//大的类型 必须写在子类类型的下边
              e.printStackTrace();
                System.out.println("出错啦");
            }
        System.out.println("aaaaaaaaaaaaaaaa");

    }

注意：

多个catch最后一个如果进行多个捕获的catch有继承关系的话大小顺序肯定是从上到下依次增大（子类->父类）,因为在try-catch中只要try中的代码一遇到异常情况就会停止去找catch中的异常类型如果父类在子类的上面的话则会出现由于java多态的特性达不到我们想要的捕获效果

public static void main(String[] args) {

          try {
               "abc".charAt(4);

                int a = 10;
                int b = 2;
                int c = a / b;
                System.out.println(c);

               String s = "x";
               System.out.println(s.length());
                    
              System.out.println("aaaaaaaaaaaa");
            }catch (ArithmeticException e){
                System.out.println("运算错误");
            }catch (NullPointerException n){//捕获与本catch类型相同的异常
                System.out.println("对象为空");
            }catch (Exception e){//大的类型 必须写在子类类型的下边
              e.printStackTrace();
                System.out.println("出错啦");
            }
        System.out.println("aaaaaaaaaaaaaaaa");

    }

（4）try-catch-finally

 /*
           try {
               可能出现异常的代码
           }catch(异常类型  e  用来接收抛出的异常对象){
                  捕获处理发生的异常
           }finally{
                   无论是否出现异常,代码都会执行
           }
            后续程序继续执行
         */
    public static void main(String[] args) {
        System.out.println(test());
    }
    public  static int test(){

        try {
            int a = 10;
            int b = 2;
            int c = a / b;
            return c;
        }catch (ArithmeticException e){
            System.out.println("运算错误");
            return -1; //即使return了 也会执行finally代码块
        }finally {
            System.out.println("cccccccccccccccccc");//IO   jdbc
            return 0;
        }
    }

注意：

在try-catch-finally中即使被捕获的catch代码中有return依然会执行finally代码块，且finally语句在return语句执行之后return返回之前执行的，具体过程看Debug功能查看详细过程

（5）try-finally

 public static void main(String[] args) {
        test();
    }
    public  static void test(){
        try {
            int a = 10;
            int b = 0;
            int c = a / b;
        }finally { //try+finally 一旦出现异常,会执行finally  ,之后程序崩掉了
            System.out.println("cccccccccccccccccc");
        }
        System.out.println("aaaaaaaaaaa");
    }

注意：

try+finally 一旦出现异常,会执行finally ,之后程序崩掉了

throws 和 throw

Throws：定义一个方法的时候可以使用throws关键字声明 （必须放在方法名的括号后） 表示此方法不处理异常，而交给方法调用处进行处理。例如: public void test throws 异常1，异常2，异常3{ }。但是这种用法一般只会出现在基层的方法中，而顶层方法就不能再抛，在抛就抛给虚拟机，虚拟机哪会处理异常，他就直接给你报错。而且任何方法都可以使用throws关键字声明异常类型，包括抽象方法。
子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常(针对编译期异常)。 使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要么继续使用throws声明。顶层只能用try-catch

public static void main(String[] args) {
        try {
            test1();
        } catch (UnsupportedEncodingException e) {
            System.out.println("编码不支持");
        }catch (ParseException p){
            System.out.println("日期解析异常");
        }catch (NullPointerException n){
            System.out.println("对象为空");
        }
        System.out.println("aaaaa");
    }

    public  static void test1() throws UnsupportedEncodingException, ParseException {
        test2();
    }

    public  static void test2() throws UnsupportedEncodingException, ParseException {
        test3();
    }

    /*
    throws NullPointerException 运行时异常 声明为运行时异常,方法调用处可以处理也可以不处理
           UnsupportedEncodingException 声明为编译期异常,那么调用在编译期间必须处理
           一般情况下,throws后面一般都声明的是编译期异常明抛出
           一般情况下,位于底层的方法都选择向上声
     */
    public  static void test3() throws NullPointerException, UnsupportedEncodingException, ParseException {
           String s = "中国";
           s.getBytes("gbk");

        SimpleDateFormat sdf = new SimpleDateFormat("");
        sdf.parse("");
    }

注意：

throws NullPointerException 运行时异常声明为运行时异常,方法调用处可以处理也可以不处理
UnsupportedEncodingException 声明为编译期异常,那么调用在编译期间必须处理
一般情况下,throws后面一般都声明的是编译期异常明抛出
一般情况下,位于底层的方法都选择向上声明（java类库中的方法）

Throw：throw关键字用于显式抛出异常,抛出的时候是抛出的是一个异常类的实例化对象. 在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也可以自己抛出。throw往往写在语句中，而非方法名后面。自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类

public static void main(String[] args) {
            //System.out.println(10/0);//由虚拟机在运行时出现异常,抛出一个此类的对象
            /*
            Exception in thread "main" java.lang.ArithmeticException: / by zero
	           at com.ff.javaexception.day2.ExceptionDemo5.main(ExceptionDemo5.java:7)
             */

            try {
                  subFileType(null);
            } catch (Exception e) {
                  e.printStackTrace();
                  System.out.println(e.getMessage());
            }

      }


      public static String subFileType(String fileName){
            if(fileName==null){
                //在方法体中,主动显示的抛出一个对用的异常对象,告知(通知)方法调用处,传入的数据有问题
               throw new NullPointerException("文件名为null了");
            }
         return fileName.substring(fileName.lastIndexOf(".")+1);
      }

注意：

throw和return都有结束方法的作用。return是返回一个值然后结束方法，throw则是告知方法调用处出入的数据有问题
throw只是抛出了异常对象，并且将方法终止了。让调用除知道了出现了问题并不能说明什么。要打印错误信息要调用被抛出的异常对象中的方法（为什么平常在我们没有处理异常的时候程序出现错误是控制台会打印那么多信息之类的，那是因为在java类库中在底层代码中java开发者已经帮你写好了异常处理的方式包括这些调用异常对象中的方法）

自定义异常

（1）概念

自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类

（2）作用

用自定义异常标记业务逻辑的异常，避免与标准异常混淆，根据自己的需要来功能来编写自定义异常

（3）语法格式

public class 异常类名 extends Exception/RuntimeException{ 
    public 异常类名(String msg){ 
        super(msg); 
    }
}

（4）应用代码

/*
   自定义异常类
   分数异常类
 */
public class ScoreException extends Exception{


    public ScoreException() {
        super();
    }

    public ScoreException(String msg) {
        super(msg);
    }
}

自定义异常的使用

package com.ff.javaexception.day2;

import java.util.ArrayList;

public class Test {

    public static void main(String[] args) {

        try {
            score(-10);
        } catch (ScoreException e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }


    public static  String score(double score) throws ScoreException {
             if(score<0){
                throw  new ScoreException("分数小于0了");
             }
             if(score>100){
                 throw  new ScoreException("分数大于100了");
             }
             if(score>=90){
                 return "A";
             }
             return "D";
    }
}

注意：

自定义异常类中往往不写其他方法，只重载需要使用的构造方法

最后，觉得有用的话，可以点赞、收藏，加关注哟，要不下次就找不见了哟！