java-异常介绍及运用_ception in thread "main" java.lang.numberformatexc-CSDN博客

本文链接：https://blog.csdn.net/qdzjo/article/details/109725549

java-异常

1.概念

在使用计算机语言进行项目开发的过程中,即使程序员把代码写得无语法错误和逻辑错误,在系统的运行过程中仍然会遇到一些问题,因为很多问题不是靠代码能够避免的.

比如:客户输入数据的格式,读取文件是否存在,网络是否始终保持通畅等等.

**异常:**在java中，阻止当前方法或作用域的情况，称之为异常。换句话说,在java语言中,将程序执行中发生的不正常情况称为"异常"。

**注意:**开发过程中的语法错误和逻辑错误不是异常.

java程序在执行过程中所发生的异常事件可分为两类:

Error:java虚拟机无法解决的严重问题.如:jvm系统内部错误、资源耗尽等严重情况.一般不编写针对性的代码进行处理.
Exception:其他因编程错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行处理.

例如:空指针访问,试图读取不存在的文件,网络连接中断等等

对于这些异常,一般有两种解决方法:

遇到异常就终止程序的运行
由程序员在编写程序时,就考虑到异常的检测,异常消息的提示,以及异常的处理.

捕获异常最理想的是在编译期间,但有的异常只有在运行时才会发生.

2.异常体系

Throwable类有两个直接子类:Exception类,Error类.

Error表示错误,可能是编译期错误或者系统错误,往往程序中并不处理.

Exception表示异常,是所有异常类的父类.

异常机制

异常分类

运行期异常:程序运行时刨除的异常,所有RuntimeException的子类都是运行期异常

例如:

/**
         * 算数异常                     错误类型                          原因
         * Exception in thread "main" java.lang.ArithmeticException: / by zero
         * 	at javaEception.day1.Eception.main(Eception.java:7)
         * 	                                            错误位置
         */
        int a = 10;
        int b = 0;
        System.out.println(a/b);

/**
         * 数组下标越界
         * Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
         * 	at javaEception.day1.Eception.main(Eception.java:20)
         */
        int[] i = new int[5];
        i[5] = 0;
        System.out.println(i[5]);

/**
         * 空指针异常
         *Exception in thread "main" java.lang.NullPointerException
         * 	at javaEception.day1.Eception.main(Eception.java:30)
         */
        String s =null;
        System.out.println(s.length());

/**
         * 数字格式化
         * Exception in thread "main" java.lang.NumberFormatException: For input string: "abc"
         * 	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
         * 	at java.lang.Integer.parseInt(Integer.java:580)
         * 	at java.lang.Integer.parseInt(Integer.java:615)
         * 	at javaEception.day1.Eception.main(Eception.java:35)
         */
        int a = Integer.parseInt("abc");
        System.out.println(a);

/**
         * 类类型转换
         *Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
         * 	at javaEception.day1.Eception.main(Eception.java:48)
         */
        String s = "abc";
        Object o = s;
        Integer i =(Integer) o ;
        System.out.println(i);

编译期异常:除去运行期的异常都是编译期异常,也称为检测异常

例如:IOException,SQLException

3.异常处理

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

程序中预先设置好对付异常的处理方法
程序运行
发现异常
对异常进行处理
处理完毕,程序继续运行

jvm默认异常处理方式:在控制台抛出对应类型的异常类对象(异常信息),终止JVM运行

也可以使用异常处理机制来处理

基本语法

try{
可能会发生异常的代码(代码尽可能缩小范围)
}catch(异常类型引用名){
异常处理代码
}finally{
必须执行代码
}

try

检测不安全的代码块(发生了异常)

try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将跳转到异常处理代码块中，即catch块。

因此，不要随意将不相关的代码放到try块中，因为随时可能会中断执行。

catch

catch语句把抓到的类型匹配的异常捕获，保证程序能继续运行下去.

catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类的顺序写，否则有编译错误.

与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。

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

例如:

public static void main(String[] args) {

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

             String s = "abc";
             s.length();

             Integer.parseInt("abc");

             System.out.println("ssssssssssss");
         }catch (ArithmeticException ex){    //catch() 中如果没有try{}中对应的异常类型,JVM也会停止运行
             System.out.println("算数异常");
         }catch (NullPointerException n){
             System.out.println("空指针异常");
         }catch (Exception e){
             System.out.println("系统忙,请稍后再试!"); //给用户提示的
             //System.out.println(e.getMessage());  //程序员自己看的  后期可以使用第三方日志组件向文件中输出信息
             e.printStackTrace();//打印异常信息到控制台
         }

        System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaa");

    }

finally

finally该内容总是会执行的，只能有一个finally语句

例如:

public static void main(String[] args) {

         /*try{
             int a = 10;
             int b = 0;
             System.out.println(a / b);
         }catch (Exception e){
             System.out.println("系统忙,请稍后再试!"); //给用户提示的
         }finally {
             System.out.println("ccccccccccccccccc");
         }
        System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaa");*/

       // System.out.println(test());//0

        test1();

    }

throws

throws,定义一个方法的时候可以使用throws关键字声明,表示此方法不处理异常,而交给方法调用处进行处理.

基本语法

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

}

注意：
1. 任何方法都可以使用throws关键字声明异常类型，包括抽象方法。
2. 子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常。
3. 使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要么继续使用throws声明。
throw

throw关键字用于显示抛出异常，抛出的时候是一个异常类的实例化对象。

在异常处理中,try语句要捕获的是一个异常对象,那么此异常对象也可以自己抛出.

语法:throw new 异常类构造方法

如: throw new RunTimeException();
```
public static void someMethod() {
if (1==1) {
    throw new RuntimeException("错误原因");
}
}
```
throw和throws的区别:

throw用于方法体中,用来抛出一个实际的异常对象,使用throw后,要么使用try catch捕获异常,要么使用throws声明异常

throws用于方法声明处,用来声明该方法可能发生的异常类型,可以是多个异常类型,用来强制调用该方法时处理这些异常

抽象方法也可以使用throws

自定义异常

自定义异常就是自己定义的异常类,也就是API中的标准异常类的直接或间接的子类作用,用自定义异常标记业务逻辑的异常,避免与标准异常混淆.

例如:

public static void main(String[] args) {
try {
            test(101);
        } catch (ScoreException e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }

    }

    public  static int test(int s)throws ScoreException{
              if(s<0||s>100){
                  //throw new RuntimeException("分数不合法"); //在程序中主动抛出异常对象,在构造方法中可以传入异常原因
                  throw new ScoreException("分数不合法");
              }
              return s;
    }
}

/*当分数不满足条件时,抛出此对象.*/
public class ScoreException extends  Exception{

    public ScoreException() {
        super();
    }

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