JavaSE-异常

最新推荐文章于 2024-06-14 15:02:13 发布

发自己的光就好

最新推荐文章于 2024-06-14 15:02:13 发布

阅读量75

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/qq_53677566/article/details/121153966

版权

JavaSE 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

异常

前言：在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。

一.概念

1.异常：

在Java语言中，将程序执行中发生的不正常情况称为“异常”。

在这里插入图片描述

2.两类异常：

（1）Error : Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理

（2）Except ion: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。

广义上的异常：程序运行时所出现的所有不正常情况
狭义上的异常：运行时,由于程序缺陷导致在运行时出现不正正常情况,出现后程序可以控制,进行处理,程序继续执行

注：我们一般处理的异常都为Eception

3.一个异常案例：

在这里插入图片描述
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vs4azs0e-1636039577826)(C:\Users\封纪元\AppData\Roaming\Typora\typora-user-images\1622422311559.png)]

图中的 **java.lang.ArithmeticException **为 算数异常

二.异常的体系

1.异常体系结构图

在这里插入图片描述
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i1kSYRCi-1636039577828)(C:\Users\封纪元\AppData\Roaming\Typora\typora-user-images\1622422494832.png)]

2.解释1图

（1）Throwable类有两个直接子类：Exception类、Error类。Error表示错误，可能是编译期错误或者系统错误，往往程序中并不处理。 Exception表示异常，是所有异常类的父类，是程序员所关心的

(2)Exception分为两类：

运行时异常（所有继承了Exception的子类RuntimeException的异常）：程序运行时抛除的异常，所有RuntimeException的子类都是运行期异常
编译期异（EXception的所有子孙类中除去所有继承RunTimeException的类）：除去运行期的异常都是编译期异常，也称为检测异常

3.常见的几种异常

java.lang.ArrayIndexOutOfBoundsException 数组越界
java.lang.NumberFormatException 数字格式化异常
java.lang.NullPointerException 空指针异常
java.lang.ClassCastException 类类型转换异常
java.lang.ArithmeticException 算数异常

三.异常处理

（异常对象中的方法）：

public void printStackTrace() **将异常信息打印出来 ** 如：e.printStackTrace();

现实中使用一些日志组件将信息输出到日志文件中

public String getMessage() 错误原因 如：e.getMessage(); 如果想把它打印出来要用输出方法

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 ,之后程序崩掉了

2.声明（throws）

（1）概念：

定义一个方法的时候可以使用throws关键字声明,表示此方法不处理异常，使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要么继续使用throws声明。而交给方法调用处进行处理，方法调用除依然可以向上声明，最高可以声明到虚拟机但是不建议声明给虚拟机；

（2）格式：

public void test throws 异常1，异常2，异常3{ 

}

（3）适用方法

任何方法都可以使用throws关键字声明异常类型，包括抽象方法。

（4）关于继承重写方法的问题

子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常，子类声明的异常类型必须小于等于父类异常(针对编译期异常)

（5）应用代码

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类库中的方法）

3.抛出（throw）

（1）概念

throw关键字用于显式抛出异常,抛出的时候是抛出的是一个异常类的实例化对象. 在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也可以自己抛出

（2）语法格式

public static void someMethod() {
    if (1==1) {
        throw new RuntimeException("错误原因"); 
    }
}

（3）应用代码

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开发者已经帮你写好了异常处理的方式包括这些调用异常对象中的方法）

4.throws和throw

throw用于方法体中，用来抛出一个实际的异常对象，使用throw后，要么使用try catch捕获异常，要么使用throws声明异常
throws用于方法声明处，用来声明该方法可能发生的异常类型，可以是多个异常类型，用来强制调用该方法时处理这些异常（编译期异常必须抛，运行时异常抛不抛都行）
抽象方法也可以使用throws

5.自定义异常

（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";
    }
}

注意：

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

发自己的光就好

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE-异常

文章目录异常一.概念1.异常：2.两类异常：3.一个异常案例：二.异常的体系1.异常体系结构图2.解释1图3.常见的几种异常三.异常处理（异常对象中的方法）：1.捕获（try-catch）概念：(1)try-catch应用代码（2）try-catch(嵌套)（3）try-catch(多catch)注意：（4）try-catch-finally注意：（5）try-finally注意：2.声明（throws）（1）概念：（2）格式：（3）适用方法（4）关于继承重写方法的问题（5）应用代码注意：3.抛出（thro
复制链接

扫一扫