【java异常处理机制】

最新推荐文章于 2024-07-26 12:28:02 发布

Speechless_小赵啊

最新推荐文章于 2024-07-26 12:28:02 发布

阅读量178

点赞数

分类专栏： java异常处理机制文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_36028783/article/details/128762113

版权

java异常处理机制专栏收录该内容

1 篇文章 0 订阅

订阅专栏

java异常处理机制：（快捷键选中后Ctrl+Alt+T）

9、注意：永远不应当在main方法上使用throws!!

含有throws的方法被子类重写时的规则

10、Java异常可以分为可检测异常，非检测异常：

11、常见的RuntimeException子类

12、异常中常用的方法

13、自定义异常

java异常处理机制：（快捷键选中后Ctrl+Alt+T）

1、异常处理

java中所有错误的超类为:Throwable。

其下有两个子类:        Error 和 Exception

Error 的子类描述的都是
        系统错误，比如虚拟机内存溢出等。

Exception 的子类描述的都是
        程序错误，比如空指针，下表越界等。

通常我们程序中处理的异常都是 Exception 。

2、异常处理机制

异常处理机制是用来处理那些可能存在的异常，但是无法通过修改逻辑完全规避的场景。

而如果通过修改逻辑可以规避的异常是bug，不应当用异常处理机制在运行期间解决！

应当在编码时及时修正

3、异常处理机制中的 try-catch

try语句块用来包含可能出错的代码片段

catch用来捕获并处理对应的异常，可以定义多个，也可以合并多个异常在一个catch中。

package exception;

/**
 * JAVA 异常处理机制
 * 
 * java.lang.Throwable是所有java中错误的顶级超类
 * 其下面派生了两个子类型：
 * Error和Exception
 * Error(错误)表示不可恢复的错误，一般表示系统级别问题，出现后通常程序就直接结束了。
 * Exception(意外，例外)是可以恢复的错误，如果正常处理完程序可以继续运行。
 * 
 * 而java异常处理机制通常关心的就是Exception这类问题，不关心Error。
 */
public class TryCatchDemo {
    public static void main(String[] args) {
        System.out.println("strata");
/**
    异常处理机制是使用在明知程序执行过程中可能出现某种不可抗因素导致的错误，无法
    通过逻辑避免掉的问题，此时针对这类异常指定B计划。
 */
 
//try语句块用来扩上可能出现异常的代码片段
        try {                                       //  try尝试
            String line = null;                     //字符串中，没有数据，null空
            
//            System.out.println(line.length());    //空就没有长度，就会报错，然后程序就会在此处截停（程序中就是闪退）
//            String line = "";
//            System.out.println(line.length());    //正常情况
            
            System.out.println(line.charAt(0));     //获取字符串指定下标的信息 因为是空串，里面没东西，会报错
            
/*       } catch (NullPointerException e) {        //  catch捕获到 （空指针异常 并赋值给 e）
            //针对try中出现 空指针异常 后的 解决办法（B计划）
            System.out.println("出现空指针并且解决了");
        } catch (StringIndexOutOfBoundsException h) {
            //针对str中出现 字符串下标越界异常 后的 解决办法（B计划）
            System.out.println("出现了字符串下标越界，并解决了");
*/
            
        } catch (NullPointerException | StringIndexOutOfBoundsException q) {
            
/** 如果针对try中多个异常处理办法相同时，可以合并到一个catch中解决来复用解决办法  */

            System.out.println("出现了 空指针异常 或者 字符串下标越界异常 的统一解决办法");
        } catch (Exception e) {
            System.out.println("反正就是出了个错");
        }
        
/**
 捕获超类异常，凡是该异常的子类型异常都可以使用这个catch处理
 这种捕获力度比较粗糙 比较大，一般不建议用特别靠上的超类。
 */
/** catch可以定义多个，针对try中不同异常有不同处理办法时可以分别捕获 */

        System.out.println("end");
    }
}

4、异常处理机制中的 finally

finally块定义在异常处理机制中的最后一块。
它可以直接跟在try之后，或者最后一个catch之后。

finally可以保证只要程序执行到了try语句块中，
无论try语句块中的代码是否出现异常，最终finally都必定执行。

finally通常用来做释放资源这类操作。

package exception;
/**
 * 异常处理机制中的finally块
 * finally块是异常处理机制的最后一块，它可以直接跟在try之后，或者最后一个catch之后。
 * finally可以保证只要程序执行到try语句块中，无论try中的代码是否出现异常，最终finally
 * 都必定执行。
 * 实际开发中我们通常会将释放资源这类操作放在finally中确保执行，比如IO中的关闭流操作。
 */
public class FinallyDemo {
    public static void main(String[] args) {
        System.out.println("start");

        try {
//            String line = "你好啊";              //正确的输出
            String line = null;                 //选中    要执行处理的语句，
            System.out.println(line.length());  //选中    Ctrl+Alt+T 快捷键，就会弹出选项框
//      try语句块中如果某句代码出现了异常，那么try中剩余代码都不会被执行！ 但finally依然会执行
            return;//void 型方法 添加的返回方法
        } catch (Exception e) {
            System.out.println("出错了");
        } finally {                             //finally 不管对错，都会 执行
            System.out.println("finally中的代码执行了");
        }

        System.out.println("end");

    }
}

5、IO操作时的异常处理机制应用

package exception;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 异常处理机制在IO操作中的应用
 *
 *      通常我们对将异常报错自行解决，做到负责任
 *
 *      快捷键：选中语句 后 Ctrl+Alt+T
 */
public class FinallyDemo2 {
    public static void main(String[] args) {
        //在try外初始化 fos ，try中就可使用了（扩大了fos的作用域）
        //初始化的操作时必须有的，如果没有初始化fos，try中fos赋值报错，就会直接走异常，finally中的fos就会认为没有被初始化，编译不会通过
        FileOutputStream fos = null;    //如果该语句写在try中，那catch中将用不了fos（定义的变量只能在当前{作用域}中使用）
        try {
            fos = new FileOutputStream("fos.dat");
            fos.write(1);
        } catch (IOException e) {
            e.printStackTrace();        // .printStackTrace 将错误信息输出到控制台上
        } finally {
   /*         //fos.close();
            这里fos.close()，如果直接写的话，会出现空指针异常，
                因为，try外定义了fos是空的，try中fos = new FileOutputStream("fos.dat");如果出现异常，
                那fos就不会被初始化，fos是空的，所以这里fos.close()就会报空指针异常
            解决办法，
                再给fos.close（）加一个分支，判断fos是不是null，是null我们就不干了
    */
            try {
                if (fos!=null){
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

6、自动关闭特性

JDK7之后，java提供了一个新的特性: 自动关闭 。
旨在IO操作中可以更简洁的使用异常处理机制完成最后的close操作。

语法:
try(
        定义需要在finally中调用close()方法关闭的对象.
){
         IO操作
}catch(XXXException e){
        ...
}

上述语法中可在try的"()"中定义的并初始化的对象必须实现了java.io.AutoCloseable接口,否则编译不通过.

package exception;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * JDK7之后java推出了一个特性:自动关闭特性
 * 旨在让我们用更简洁的语法完成IO操作的异常处理机制(主要就是简化了finally关闭流的操作)
 */
public class AutoCloseableDemo {
    public static void main(String[] args) {
        /*
            该特性是编译器认可的，并非虚拟机。实际上编译器编译完毕后的样子可参考FinallyDemo2
         */
        try(
                //只有实现了AutoCloseable接口的类才可以在这里定义!编译器最终会补充代码在finally中调用其close关闭
                FileOutputStream fos = new FileOutputStream("fos.dat");
        ){
            fos.write(1);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

上述代码是编译器认可的，而不是虚拟机。

编译器在编译上述代码后会在编译后的class文件中改回成FinallyDemo2案例的代码样子。

7、throw关键字

throw用来对外主动抛出一个异常，通常下面两种情况我们主动对外抛出异常:

1、当程序遇到一个满足语法，但是不满足业务要求时，
可以抛出一个异常告知调用者。

2、程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时，
可以抛出给调用者。

package exception;

/**
 * 测试异常的抛出
 */
public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) throws Exception {
        if(age<0||age>100){
            //使用throw对外抛出一个异常
            throw new RuntimeException("年龄不合法!");
        }
        this.age = age;
    }
}
package exception;

/**
 * throw关键字，用来对外主动抛出一个异常。
 * 通常下面两种情况我们主动对外抛出异常:
 * 1:当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。
 * 2:程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。
 */
public class ThrowDemo {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(10000);//符合语法，但是不符合业务逻辑要求。
        System.out.println("此人年龄:"+p.getAge());
    }
}

8、throws关键字

当一个方法中使用throw抛出一个非RuntimeException的异常时，
就要在该方法上使用throws声明这个异常的抛出。
此时调用该方法的代码就必须处理这个异常，否则编译不通过。

package exception;

/**
 * 测试异常的抛出
 */
public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    /**
     * 当一个方法使用throws声明异常抛出时,调用此方法的代码片段就必须处理这个异常
     */
    public void setAge(int age) throws Exception {
        if(age<0||age>100){
            //使用throw对外抛出一个异常
//            throw new RuntimeException("年龄不合法!");
            //除了RuntimeException之外,抛出什么异常就要在方法上声明throws什么异常
            throw new Exception("年龄不合法!");
        }
        this.age = age;
    }
}

当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理这个异常，否则编译不通过。
处理手段有两种:

使用try-catch捕获并处理这个异常

在当前方法(本案例就是main方法)上继续使用throws声明该异常的抛出给调用者解决。具体选取那种取决于异常处理的责任问题。

package exception;

/**
 * throw关键字，用于主动对外抛出一个异常
 */
public class ThrowDemo {
    public static void main(String[] args){
        System.out.println("程序开始了...");
        try {
            Person p = new Person();
            /*
                当我们调用一个含有throws声明异常抛出的方法时,编译器要求
                我们必须添加处理异常的手段,否则编译不通过.而处理手段有两种
                1:使用try-catch捕获并处理异常
                2:在当前方法上继续使用throws声明该异常的抛出
                具体用哪种取决于异常处理的责任问题
             */
            p.setAge(100000);//典型的符合语法，但是不符合业务逻辑要求
            System.out.println("此人年龄:"+p.getAge()+"岁");
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("程序结束了...");
    }
}

9、注意：永远不应当在main方法上使用throws!!

含有throws的方法被子类重写时的规则

package exception;

import java.awt.*;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;

/**
 * 子类重写超类含有throws声明异常抛出的方法时对throws的几种特殊的重写规则
 */
public class ThrowsDemo {
    public void dosome()throws IOException, AWTException {}
}
class SubClass extends ThrowsDemo{

    public void dosome()throws IOException, AWTException {}

    //可以不再抛出任何异常
    public void dosome(){}

    //可以仅抛出部分异常
    public void dosome()throws IOException {}

    //可以抛出超类方法抛出异常的子类型异常
    public void dosome()throws FileNotFoundException {}

    //不允许抛出额外异常(超类方法中没有的,并且没有继承关系的异常)
    public void dosome()throws SQLException {}

    //不可以抛出超类方法抛出异常的超类型异常
    public void dosome()throws Exception {}
}

10、Java异常可以分为可检测异常，非检测异常：

可检测异常：
可检测异常经编译器验证，对于声明抛出异常的任何方法，编译器将强制执行处理或声明规则，不捕捉这个异常，编译器就通不过，不允许编译

非检测异常：
非检测异常不遵循处理或者声明规则。在产生此类异常时，不一定非要采取任何适当操作，编译器不会检查是否已经解决了这样一个异常

RuntimeException 类属于非检测异常，因为普通JVM操作引起的运行时异常随时可能发生，此类异常一般是由特定操作引发。但这些操作在java应用程序中会频繁出现。因此它们不受编译器检查与处理或声明规则的限制。

11、常见的RuntimeException子类

IllegalArgumentException：
        抛出的异常表明向方法传递了一个不合法或不正确的参数

NullPointerException：
        当应用程序试图在需要对象的地方使用 null 时，抛出该异常

ArrayIndexOutOfBoundsException：
        当使用的数组下标超出数组允许范围时，抛出该异常

ClassCastException：
        当试图将对象强制转换为不是实例的子类时，抛出该异常

NumberFormatException：
        当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。

12、异常中常用的方法

用于将当前错误信息输出到控制台
e.printStackTrace();
获取错误消息 . 记录日志的时候或提示给用户可以使用它
String message = e.getMessage();

package exception;

/**
 * 异常常见的方法
 */
public class ExceptionApiDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了");

        try {
            String str = "abc";
            System.out.println(Integer.parseInt(str));
        } catch (NumberFormatException e) {
            //异常最常用的方法,用于将当前错误信息输出到控制台
            e.printStackTrace();

            //获取错误消息.记录日志的时候或提示给用户可以使用它
            String message = e.getMessage();
            System.out.println(message);

        }

        System.out.println("程序结束了");
    }
}

13、自定义异常

自定义异常通常用来定义那些业务上的异常问题。
定义自定义异常需要注意以下问题:

异常的类名要做到见名知义

需要是Exception的子类

提供超类异常提供的所有种类构造器

package exception;

/**
 * 非法的年龄异常
 *
 * 自定义异常通常用来说明业务上的错误.
 * 自定义异常要注意以下问题:
 * 1:定义的类名要做到见名知义
 * 2:必须是Exception的子类
 * 3:提供Exception所定义的所有构造方法
 */
public class IllegalAgeException extends Exception{
    public IllegalAgeException() {
    }

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

    public IllegalAgeException(String message, Throwable cause) {
        super(message, cause);
    }

    public IllegalAgeException(Throwable cause) {
        super(cause);
    }

    public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

package exception;

/**
 * 测试异常的抛出
 */
public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    /**
     * 当一个方法使用throws声明异常抛出时,调用此方法的代码片段就必须处理这个异常
     */
    public void setAge(int age) throws IllegalAgeException {
        if(age<0||age>100){
            //使用throw对外抛出一个异常
//            throw new RuntimeException("年龄不合法!");
            //除了RuntimeException之外,抛出什么异常就要在方法上声明throws什么异常
//            throw new Exception("年龄不合法!");

            //抛出自定义异常
            throw new IllegalAgeException("年龄超范围:"+age);

        }
        this.age = age;
    }
}

package exception;

/**
 * throw关键字，用于主动对外抛出一个异常
 */
public class ThrowDemo {
    public static void main(String[] args){
        System.out.println("程序开始了...");
        try {
            Person p = new Person();
            /*
                当我们调用一个含有throws声明异常抛出的方法时,编译器要求
                我们必须添加处理异常的手段,否则编译不通过.而处理手段有两种
                1:使用try-catch捕获并处理异常
                2:在当前方法上继续使用throws声明该异常的抛出
                具体用哪种取决于异常处理的责任问题
             */
            p.setAge(100000);//典型的符合语法，但是不符合业务逻辑要求
            System.out.println("此人年龄:"+p.getAge()+"岁");
        } catch (IllegalAgeException e) {
            e.printStackTrace();
        }

        System.out.println("程序结束了...");
    }
}

Speechless_小赵啊

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
【java异常处理机制】

在当前方法(本案例就是main方法)上继续使用throws声明该异常的抛出给调用者解决。具体选取那种取决于异常处理的责任问题。当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理这个异常，否则编译不通过。自定义异常通常用来定义那些业务上的异常问题。使用try-catch捕获并处理这个异常。throw用来对外主动抛出一个异常。提供超类异常提供的所有种类构造器。需要是Exception的子类。异常的类名要做到见名知义。
复制链接

扫一扫