Java#异常

已于 2022-04-24 17:08:15 修改
阅读量442 收藏
点赞数 1
分类专栏： JavaSE 文章标签： java异常 jvm对异常的实现 UncaughtHandler 多异常捕获 java异常注意点
于 2022-04-21 19:10:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38350635/article/details/124325091
版权

简介

Java语言中Throwable是所有异常的根类，Throwable 派生了两个直接子类Error 和 Exception。Error 表示应用程序本身无法克服和恢复的一种严重问题，触发Error时会终止线程甚至是虚拟机。Exception 表示程序还能够克服和恢复的问题，Exception按照处理时机可以分为编译时异常和运行时异常。

编译时异常都是可以被修复的异常，代码编译期间Java程序必须显式处理编译时异常，否则无法编译通过。运行时异常通常是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下软件系统可能会继续运行，严重情况下软件系统才会死掉。

请添加图片描述

异常的处理

异常处理方案

Java中异常处理有两种方案，捕获处理异常和抛出异常。

对编译时异常处理方案有两种，当前方法知道如何处理该异常则捕获处理。当前方法不知道如何处理则在定义该方法时声明抛出该异常。

运行时异常只有当代码在运行时才发现的异常，编译时不需要捕获处理。如除数是0、数组下标越界等等，其产生频繁，处理麻烦，若显示声明或者捕获将会对程序的可读性和运行效率影响很大。所以由虚拟机自动检测抛出。当然也可以主动显示捕获处理。

异常相关关键字

Java的异常机制主要依赖于try、catch、finally、throw和throws五个关键字。一般try，catch，finally结合使用，用于捕获异常。throws，throw单独使用，用于抛出异常。

      // try catch finally
       try {
             // 可能触发异常的代码
        } catch (XXXException e) { // XXXException  ：代表异常类型 
            // 这里进行处理异常
        } finally {
           //这里进行资源释放
       }

try后紧跟一个花括号扩起来的代码块简称try块，try块它里面放置可能引发异常的代码。catch后定义一个异常类型和一个代码块。当try块某段代码触发了异常并匹配上catch定义的异常类型，这时便走catch块处理逻辑。

try 代码块后面可以跟着多个 catch 代码块，用于捕获不同类型的异常。Java 虚拟机会从上到下匹配异常处理器。因此，前面的 catch 代码块所捕获的异常类型不能覆盖后面的，否则编译器会报错。

finally块跟catch块之后，finally块用于回收在try块里打开的物理资源，异常机制会保证finally块总被执行。


    //throws 抛出异常,方法签名处抛出。
    private static void test() throws XXXException {}
    
    //throw 作为语句使用，代码中直接抛出一个异常。 throw new XXXException();
    private static void getCode(String type) {
       if (type == null) throw new IllegalArgumentException("参数不能为空");
    }

throws关键字主要在方法签名中使用，用于声明该方法可能抛出的异常。throw用于抛出一个实际的异常，throw可以单独作为语句使用，抛出一个具体的异常对象。

异常处理栗子

（1）编译时异常

    public static void main(String[] args) {
        File file = new File("F://a.txt");
        if (!file.exists()) {
            file.createNewFile(); // 这段代码直接运行，这里编译不通过，报编译时异常。
        }
    }

编译时异常在代码编译期间就会报错（注意编译期间报错的不一定都是编译时异常），这种异常在编码期间需要手动捕获或者抛出处理~

/**
 * Create by SunnyDay on 2022/04/21 18:26
 */
public class ExceptionDemo {
    public static void main(String[] args) throws IOException {
        tryCatch();
        throwsException(); // 这里选择继续抛出给main
    }

    /**
     * 捕获异常栗子
     */
    private static void tryCatch() {
        try {
            File file = new File("F://a.txt");
            if (!file.exists()) {
                file.createNewFile();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            System.out.println("finally 块");
        }

    }

    /**
     * 方法签名处抛出异常栗子。
     * 注意若是此方法被其他方法A调用，那么A需要捕获或者抛出处理。
     */
    private static void throwsException() throws IOException {
        File file = new File("F://a.txt");
        if (!file.exists()) {
            file.createNewFile();
        }
    }
}

（2）运行时异常

    private static void runtimeException(String name) {
        name.length(); //name 为空时java.lang.NullPointerException.直接crash。
    }

运行时异常一般为开发人员代码考虑不周引起的，一般不需要主动来捕获或者抛出的~ 不过若是需要也可以主动捕获处理~如下。

    /**
     * 不过一般不会建议采取捕获处理的方式，完全可通过name的判空处理。
     */
    private static void runtimeException(String name) {
        // 捕获，出现异常也不会导致crash，不影响try catch 块之外的逻辑。
        try {
            name.length(); //java.lang.NullPointerException
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

（3）访问异常信息

如果需要在catch块中访问异常对象的相关信息，则可以通过访问catch块后的异常形参来获得。当JVM决定调用某个catch块来处理该异常对象时，会将异常对象赋给catch块后的异常参数，这时我们可通过该参数来获得异常的相关信息。常用方法如下：

  • getMessage()：返回该异常的详细描述字符串。
  • printStackTrace()：将该异常的跟踪栈信息输出到标准错误输出。
  • printStackTrace(PrintStream s)：将该异常的跟踪栈信息输出到指定输出流。
  • getStackTrace()：返回该异常的跟踪栈信息。
注意点

看似两三个栗子吧异常过了一遍，其实异常相关的东西还是很多的~

（1）不管程序代码块是否处于try块中，甚至包括catch块中的代码，只要执行该代码块时出现了异常，系统总会自动生成一个异常对象。如果程序没有为这段代码定义任何的catch块，则Java运行时环境无法找到处理该异常的catch块，程序就在此异常退出。

（2）触发异常时虚拟机会生成对应的异常，并会自上而下遍历catch中定义的异常条目，寻找匹配的异常条目。catch 中定义异常条目时要遵循只能扩大或者不相关的原则，否则编译失败。

（3）在Java 7以前，每个catch块只能捕获一种类型的异常；但从Java 7开始，一个catch块可以捕获多种类型的异常。多异常捕获需要注意：

  • 捕获多种类型的异常时，多种异常类型之间用竖线"|"隔开。

  • 捕获多种类型的异常时，异常变量有隐式的final修饰，因此程序不能对异常变量重新赋值。

    private static void mutipleException(){
        // 多异常捕获，如下catch块可以捕获处理2种异常。
        try {
        
        }catch (ArrayIndexOutOfBoundsException|NumberFormatException e){
            e = new IllegalArgumentException("") // 编译报错，多异常不能重新赋值。
        }
        
        // 单个异常捕获
        try {
            
        }catch (Exception e){
            e = new IllegalArgumentException(""); // 编译通过，单个异常可以赋值。
        }
    }

（4）在通常情况下，不要在finally块中使用如return或throw等导致方法终止的语句，一旦在finally块中使用了return或throw语句，将会导致try块、catch块中的return、throw语句失效。

（5）try、catch中的return语句、异常触发等导致方法结束的case不会影响finally代码块的执行。


    public static void main(String[] args) {
        System.out.println("test return value:"+test());
    }
    
    private static int test() {
        try {
            int a = 10 / 0; //  ArithmeticException: / by zero
        } catch (Exception e) {
            return 0;
        } finally {
            System.out.println("finally");
        }
        System.out.println("test finish");
        return 1;
    }
log:

finally
test return value:0

可见finally最终打印出来了，证明了我们的观点，那么为啥方法最终打印的返回值是0，而不是1呢？其实流程是这样的~

首先代码执行到try块触发ArithmeticException异常，然后catch块捕获住处理，不过异常机制有这么一个原则如果在 catch 中遇到了 return 或者异常等能使该函数终止的话，那么finally就必须先执行完finally代码块里面的代码然后再返回到catch中抛出或者return处。最终执行catch return语句方法结束。后续的代码不会再执行了。

不妨可以修改代码验证下,如下catch 代码块执行完后会继续走try catch finally 之外的代码~

    private static int test() {
        try {
            int a = 10 / 0; //  ArithmeticException: / by zero
        } catch (Exception e) {
            System.out.println("catch");
        } finally {
            System.out.println("finally");
        }
        System.out.println("test finish");
        return 1;
    }
    
log:

catch
finally
test finish
test return value:1

来个栗子再让我们更好巩固下，彻底理解他 emmm~ 如下方法的返回值是几？

    private static int test() {
        try {
            int a = 10 / 0; //  ArithmeticException: / by zero
            return 1;
        } catch (Exception e) {
            return 2;
        } finally {    
            return 3;
        }
    }

代码执行到try的 int a这里会触发ArithmeticException，这时由异常处理器捕获，走catch中return 2，但是由于java的异常执行机制此时会先执行finally中的return3。finally这里正好碰到了return语句，正常结束方法。

若是finally只是处理一些资源关闭的代码，这里未return 3，那么本方法的返回值就是2喽~

（6）除非在try块、catch块中调用了退出虚拟机的方法，否则不管在try块、catch块中执行怎样的代码，出现怎样的情况，异常处理的finally块总会被执行。

    private static int test() {
        try {
            int a = 10 / 0; //  ArithmeticException: / by zero
        } catch (Exception e) {
            System.out.println("catch");
            System.exit(0);
        } finally {
            System.out.println("finally");
        }
        return 0;
    }
log：

catch
Process finished with exit code 0

如上，首先触发ArithmeticException异常，此时会走到catch代码块，执行了打印语句后执行System.exit(0) 直接退出JVM。

（7）try catch finally 执行机制存在异常丢失的情况

    /**
     * try中捕获异常A，catch中又触发异常B，这时finally执行完后系统只会抛出异常B。
     * 这种case也可以看做try catch的弊端，丢失了try中的异常。
     * */
    private static void test() {
        try {
            int a = 10 / 0; //  ArithmeticException: / by zero
        } catch (Exception e) {
            String a = null;
            a.length(); // finally 执行完毕后这里最终由系统抛出NullPointerException
        } finally {
            System.out.println("finally");
        }
    }

    /**
     * try中捕获异常A，catch中又触发异常B，这时finally执行又触发异常C系统只会抛出异常C。
     * 这种case也可以看做try catch的弊端，丢失了try，catch中的异常。
     */
    private static void test() {
        try {
            int a = 10 / 0; //  ArithmeticException: / by zero
        } catch (Exception e) {
            String a = null;
            a.length(); // NullPointerException
        } finally {
           Integer.parseInt("aaa"); //代码执行到这里只会抛出NumberFormatException。上述两异常忽略。
           System.out.println("finally");
        }
    }

Java 7 Supressed 异常以及语法糖

前面了解到try catch 中的异常存在丢失的情况，为了解决这个问题，java7引入了Supressed 异常来解决这个问题。这个新特性允许开发人员将一个异常附于另一个异常之上。因此，抛出的异常可以附带多个异常的信息。

Java 7 专门构造了一个名为 try-with-resources 的语法糖，在字节码层面自动使用 Supressed 异常。当然，该语法糖的主要目的并不是使用 Supressed 异常，而是精简资源打开关闭。因为在 Java 7 之前，对于打开的资源，我们需要定义一个 finally 代码块，来确保该资源在正常或者异常执行状态情况下都能关闭。这种做法使代码太臃肿了~

Java 7 的 try-with-resources 语法糖，极大的简化了try catch finally代码。程序可以在 try 关键字后声明并实例化实现了 AutoCloseable 接口的类，编译器将自动添加对应的 close 操作。在声明多个 AutoCloseable 实例的情况下，编译生成的字节码类似于try catch finally手工编写代码的编译结果。与手工代码相比，try-with-resources 还会使用 Supressed 异常的功能，来避免原异常 “被消失”。

（1）自动关闭资源

系统提供了一些类实现了AutoCloseable接口 ，若直接使用try-with-resources 语法糖则不需要再使用finally做繁琐的关闭处理的工作~

    public static void main(String[] args) throws Exception {

        /**
         * 1、try()中进行变量定义（创建、赋值），类必须实现了AutoCloseable接口（或者是AutoCloseable实现类）。
         * 2、try后的代码块中可进行逻辑的操作。
         * 3、自动关闭资源的try语句相当于包含了隐式的finally块，执行了close回调，因此这个try语句可以既没有catch块，
         *    也没有finally块。
         * 4、注意AutoCloseable#close()方法抛出了Exception
         * */
        try (
                BufferedReader br = new BufferedReader(new FileReader("F://a.txt"));
                PrintStream pr = new PrintStream(new FileOutputStream("F://b.txt"))
        ) {
            br.readLine();
            pr.write("emmm".getBytes());
        }
    }

BufferedReader、PrintStream都间接实现了AutoCloseable 接口，把它们放在try语句中声明、初始化，try语句会自动关闭它们。当然我们也可以自定义类实现接口即可，在接口中实现资源的处理工作。接下来验证下异常的捕获~

（2）避免异常的丢失

/**
 * Create by SunnyDay on 2022/04/22 17:37
 */
public class Demo implements AutoCloseable {

    private String desc;

    public Demo(String name) {
        this.desc = name;
    }

    public static void main(String[] args) throws Exception {
        try (
                Demo demo1 = new Demo("1");
                Demo demo2 = new Demo("2")) {

                int a = 10/0; // 执行代码 触发异常
        }
    }


    @Override
    public void close() throws Exception {
        // 这里直接抛出一个异常，验证 finally中触发了异常工作。
        throw new IllegalArgumentException();
    }
}

log： 打印所有的异常信息

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at Demo.main(Demo.java:21)
	Suppressed: java.lang.IllegalArgumentException
		at Demo.close(Demo.java:29)
		at Demo.main(Demo.java:22)
	Suppressed: java.lang.IllegalArgumentException
		at Demo.close(Demo.java:29)
		at Demo.main(Demo.java:22)

异常实现原理

异常实例的构造十分昂贵。这是由于在构造异常实例时，Java 虚拟机便需要生成该异常的栈轨迹（stack trace）。该操作会逐一访问当前线程的 Java 栈帧，并且记录下各种调试信息，包括栈帧所指向方法的名字，方法所在的类名、文件名，以及在代码中的第几行触发该异常。

在生成栈轨迹时，Java 虚拟机会忽略掉异常构造器以及填充栈帧的 Java 方法，直接从新建异常位置开始算起。此外，Java 虚拟机还会忽略标记为不可见的 Java 方法栈帧。

既然异常实例的构造十分昂贵，我们是否可以缓存异常实例，在需要用到的时候直接抛出呢？

从语法角度上来看，这是允许的。然而，该异常对应的栈轨迹并非 throw 语句的位置，而是新建异常的位置。因此，这种做法可能会误导开发人员，使其定位到错误的位置。这也是为什么在实践中，我们往往选择抛出新建异常实例的原因。

jvm是如何实现异常的？

class 文件被编译成字节码时，每个方法都附带一张异常表。异常表中的每一个条目代表一个异常处理器。该处理器由from指针、to指针、target指针、所捕获的异常类型组成。这些指针的值是字节码索引，用以定位字节码。

  • from 、to 表示表示异常处理器监控范围，即用try代码块监控的范围。
  • target表示异常处理器的起始位置，即catch起始位置。
  • 异常类型即为xxxException。
/**
 * Create by SunnyDay on 2022/04/22 18:45
 */
public class Test {
    public static void main(String[] args) {
        // 异常条目1（try catch finally块就是一个异常处理器）
        try {// from
            File file = new File("F://a.txt");
            if (!file.exists()) {
                file.createNewFile();
            }
        } catch (IOException e) {//to(不包括to 可以这样记住范围“包左不包右”也即[from,to))。  target，这里也是异常处理器
                                // 开始位置
            e.printStackTrace();
        } finally {
            System.out.println("finally1");
        }

        // 异常条目2
        try {// from
             int a =  1/0;
        } catch (Exception e) {// to ,target
            e.printStackTrace();
        } finally {
            System.out.println("finally2");
        }

    }
}

//javap 命令 查看class文件：javap -c -l Test.class  main方法中生成的异常表如下：

    Exception table:
       from    to  target type
           0    22    33   Class java/io/IOException // 异常条目1
           0    22    49   any
          33    38    49   any
          60    64    75   Class java/lang/Exception // 异常条目2
          60    64    91   any
          75    80    91   any

当程序触发异常时，Java 虚拟机会生成一个要抛出的异常实例，然后自上至下遍历异常表中的所有条目。当触发异常的字节码的索引值在某个异常表条目的监控范围内，Java 虚拟机会判断要抛出的异常和该条目想要捕获的异常是否匹配。如果匹配，Java 虚拟机会将控制流转移至该条目 target 指针指向的字节码。

如果遍历完所有异常表条目，Java 虚拟机仍未匹配到异常处理器，那么它会弹出当前方法对应的Java 栈帧，并且在调用者中重复上述操作。在最坏情况下，Java 虚拟机需要遍历当前线程 Java栈上所有方法的异常表。最终把异常抛出。

finally 代码块的编译比较复杂，当前版本 Java 编译器的做法，是复制 finally 代码块的内容，分别放在 try-catch 代码块所有正常执行路径以及异常执行路径的出口中。

在这里插入图片描述
针对异常执行路径，Java 编译器会生成一个或多个异常表条目，监控整个 try-catch 代码块，并且捕获所有种类的异常。这些异常表条目的 target 指针将指向另一份复制的 finally 代码块。并且，在这个 finally 代码块的最后，Java 编译器会重新抛出所捕获的异常。

如果 catch 代码块捕获了异常，并且触发了另外一个异常，那么 finally 捕获并重抛的异常是哪个呢？答案是后者，也就是说原本的异常便会被忽略掉，这对于代码调试来说十分不利。

UncaughtExceptionHandler

介绍

Java中，当一个线程如果没有显式处理异常而抛出时Jvm会将该异常事件报告给该线程对象的 UncaughtExceptionHandler 进行处理，如果线程没有设置 UncaughtExceptionHandler，则默认会把异常栈信息输出到终端而使程序直接崩溃。所以如果我们想在线程意外崩溃时做一些处理就可以通过实现 UncaughtExceptionHandler 来满足需求。

栗子
/**
 * Create by SunnyDay on 2022/04/24 11:07
 */
public class CrashHandler implements Thread.UncaughtExceptionHandler {

    private volatile static CrashHandler INSTANCE;

    private CrashHandler() {
    }

    public static CrashHandler getINSTANCE() {
        if (INSTANCE == null) {
            synchronized (CrashHandler.class) {
                if (INSTANCE == null) {
                    INSTANCE = new CrashHandler();
                }
            }
        }
        return INSTANCE;
    }

    @Override
    public void uncaughtException(Thread t, Throwable e) {
        printInfo(t, e);
        collectDeviceInfo();
        saveCatchInfo2File(e);
    }

    private void printInfo(Thread t, Throwable e) {
        System.out.println("异常线程:" + t.getName() + " 异常信息:" + e.getMessage());
    }

    private void collectDeviceInfo() {
        System.out.println("收集用户设备信息");
    }

    private void saveCatchInfo2File(Throwable ex) {
        System.out.println("异常信息保存到文件");
    }
}



/**
 * Create by SunnyDay on 2022/04/24 11:06
 */
public class Test {
    public static void main(String[] args) {
        getException();
        new Thread(() -> createAnException1(), "工作线程1").start();
        new Thread(() -> createAnException2(), "工作线程2").start();
    }

    /**
     * 捕获所有线程未捕获异常。
     */
    private static void getException() {
        Thread.setDefaultUncaughtExceptionHandler(CrashHandler.getINSTANCE());
    }

    /**
     * 模拟一个异常 "除0异常"
     */
    private static void createAnException1() {
        int a = 10 / 0;
    }

    /**
     * 模拟一个异常 "NumberFormatException"
     */
    private static void createAnException2() {
        Integer.parseInt("sss");
    }
}

上述Test#main方法运行后最终会走CrashHandler#uncaughtException log如下：

异常线程:工作线程1异常信息:/ by zero
收集用户设备信息
异常信息保存到文件

异常线程:工作线程2异常信息:For input string: "sss"
收集用户设备信息
异常信息保存到文件
源码分析

上面的栗子中使用到了Thread.setDefaultUncaughtExceptionHandler()，其实Thread还有一个方法setUncaughtExceptionHandler那么二者有啥区别呢？ 先来个结论再看源码~

  • Thread.setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh)：用于设置一个默认的全局异常处理器，也就是给所有的线程都设置这个处理器。
  • Thread.setUncaughtExceptionHandler(UncaughtExceptionHandler eh)：给指定线程设置，用于对特定的线程进行未捕获的异常处理。
class Thread implements Runnable {
...
    /* The group of this thread */
    private ThreadGroup group;
    
    @FunctionalInterface
    public interface UncaughtExceptionHandler {
        void uncaughtException(Thread t, Throwable e);
    }
    
    // 单独线程的UncaughtExceptionHandler 对象
    private volatile UncaughtExceptionHandler uncaughtExceptionHandler;
    // 全局的UncaughtExceptionHandler 对象
    private static volatile UncaughtExceptionHandler defaultUncaughtExceptionHandler;

    //设置全局的UncaughtExceptionHandler 对象
    public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(
                new RuntimePermission("setDefaultUncaughtExceptionHandler")
                    );
        }

         defaultUncaughtExceptionHandler = eh;
     }

    public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler(){
        return defaultUncaughtExceptionHandler;
    }

    //为单独线程指定UncaughtExceptionHandler 对象
    public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
        checkAccess();
        uncaughtExceptionHandler = eh;
    }

    /**
      uncaughtExceptionHandler对象为null则返回group。ThreadGroup 类对象在Thread构造中初始化。

      这里不妨猜测下ThreadGroup必定实现了UncaughtExceptionHandler接口。
     */
    public UncaughtExceptionHandler getUncaughtExceptionHandler() {
        return uncaughtExceptionHandler != null ?
            uncaughtExceptionHandler : group;
    }
...
}

到这就能明白了 setDefaultUncaughtExceptionHandler 和 setUncaughtExceptionHandler 的区别了。线程崩溃时异常抛出的顺序是先调用 Thread 的 getUncaughtExceptionHandler 查看UncaughtExceptionHandler 对象是否有值，如果有就直接处理，没有就调用 ThreadGroup的逻辑处理~

ThreadGroup是UncaughtExceptionHandler 在 JDK 的默认实现类。内部调用 Thread 的 getDefaultUncaughtExceptionHandler() 获取 handler 进行处理，如果默认 handler 也没有处理就直接执行正常的异常流程使程序崩溃~

//这个类实现了UncaughtExceptionHandler 接口。
public class ThreadGroup implements Thread.UncaughtExceptionHandler {

    private final ThreadGroup parent;
···
    public void uncaughtException(Thread t, Throwable e) {
        if (parent != null) {//ThreadGroup 无参构造中直接parent == null。这个值一般为null。
            parent.uncaughtException(t, e);
        } else {
        /**
           ThreadGroup 其实也是调用 Thread.getDefaultUncaughtExceptionHandler()来获取UncaughtExceptionHandler 对象的。

            当我们通过setDefaultUncaughtExceptionHandler设置过UncaughtExceptionHandler对象时则调用
            UncaughtExceptionHandler#uncaughtException
            当未设置过UncaughtExceptionHandler对象时打印异常信息，后续就是jvm的crash了~
         */
            Thread.UncaughtExceptionHandler ueh =
                Thread.getDefaultUncaughtExceptionHandler();
            if (ueh != null) {
                ueh.uncaughtException(t, e);
            } else if (!(e instanceof ThreadDeath)) {
                System.err.print("Exception in thread \""
                                 + t.getName() + "\" ");
                e.printStackTrace(System.err);
            }
        }
    }
···
}

End

参考：深入拆解 Java 虚拟机

参考：UncaughtExceptionHandler 相关问题解析

dev晴天
关注
专栏目录
Java 异常处理 -- Java 语言的异常、异常链与断言
栗筝i的博客
06-13 3436
世界上存在永远不会出错的程序吗？也许这只会出现在程序员的梦中。随着编程语言和软件的诞生，异常情况就如影随形地纠缠着我们，只有正确处理好意外情况，才能保证程序的可靠性。
java常见异常总结
11-29
本文将详细介绍一些常见的Java异常及其发生场景，帮助读者更好地理解和处理这些异常。 #### 1. `java.lang.NullPointerException` (空指针异常) - **定义**：当程序试图访问一个尚未初始化的对象，或者尝试访问一...
JAVA 基础笔记
zhangMY12138的博客
09-08 295
  面向对象的三大特征 继承 关键字：extends    扩展 语法： public class A extends B 理解： 类A对类B进行扩展 在现实世界中的体现就是特殊与一般的关系。 ISA原则： A is a B  A是一种B   本质上：A是一种特殊的B   A是特殊 B是一般 燕子（A）是一种鸟（B） 动物（A）是一种鸟（B）  逻辑不成立 Class A ...
java 中的suppressedException
ai_xiangjuan的博客
01-14 4402
SuppressedException 用来保存被屏蔽的异常，可通过Throwable.getSuppressed()获得。添加的话用addSuppressed(Throwable exception)，这个函数一般是在try-with-resources语句中由自动调用的。 try-with-resources中抑制异常的使用 在使用try-with-resources语句的时候，异常
java中三种可能导致异常的情况_java中常见的几种异常
weixin_39633089的博客
02-13 715
异常javax.servlet.jsp.JspException: Cannot retrieve mapping for action/Login(/Login是你的action名字)可能原因action没有再struts-config.xml 中定义，或没有找到匹配的action，例如在JSP文件中使用action="Login.do".将表单提交给Login.do处理，如果出现上述异常，请...
java 重定向，第一次404，原因和解决
Zero丶轩
02-18 3161
The request was rejected because the URL contained a potentially malicious String ";" 原因和解决方案
【深入理解JVM】早期编译优化
dev晴天的博客
06-23 547
一、简介 1、Java 语言的 ”编译器“ 其实是一段 ”不确定“ 的操作过程： 因为它可能是指一个前端编译器（javac）把 java 文件转变成 class 文件的过程； 也可能是指虚拟机的后端运行期编译器（JIT）把字节码（class文件）转变成机器码的过程； 还可能是指使用静态提前编译器（AOT 编译器）直接把 java 文件编译成本地机器代码的过程。 2、下面列举了这三类编译过程中一些比较有代表的编译器： 前端编译器：Javac JIT 编译器：HotSpot VM 的 C1、C2 编译器
Java-Edge#Java-Interview-Tutorial#Java异常之IllegalMonitorStateExce
07-25
1. By executing a synchronized instance method of that object. 2. By executing t
applenele#blog#java异常1
07-25
checked exception（检查异常），也称非运行时异常（运行时异常以外的异常就是非运行时异常），java编译器强制程序员必须进行捕获处理，比如常见的I
JAVA 自定义异常 全局捕获
12-04
自己编写异常类型 ，自定义错误异常进行全局捕捉。实现项目全局的拦截定义输出。。。
SpringBoot中的配置文件
晴天的博客
05-04 818
SpringBoot中, properties配置文件, yml配置文件和指定静态资源文件夹
【深入理解JVM】JVM 类加载机制
dev晴天的博客
06-21 303
一、类加载流程 1、类加载机制 jvm把描述类的数据的class文件加载到内存中，并对数据进行校验、解析、初始化、最终形成可被jvm使用的java类型，这就是jvm的类加载机制。 ps：在 Java 语言里面，类型的加载、链接和初始化都是程序运行期间完成的，这种策略虽然会令类加载时稍微增加一些性能开销，但是会为 Java 应用程序提供高度的灵活性。比如我们可以自定义类加载器。 2、类加载流程 类从被加载在到虚拟机的运行内存开始，到被卸载出内存结束完整的生命周期如下： 加载->链接->初始化-&g
谈谈Android的中的Drawable
dev晴天的博客
06-16 4951
为什么要全面理解Drawable 1、本文内容看似简单，但是drawable的种类比较繁多，导致开发者对不同的drawable理解比较混乱。 2、熟练掌握各种类型的drawable可以方便我们做出一些特殊的ui效果。 drawable 在开发中优点有很多 1、使用简单，比自定义的成本要低。 2、非图片类型的drawable占用空间较小，对减小apk的体积有很大的帮助。 Drawable 简...
Java开发遇见的异常错误
weixin_51833408的博客
07-22 1440
文章目录前言一、MySQL二、IDEA三、Mybatis四、Spring框架总结 前言 记录开发过程中常见的异常。 一、MySQL 1、MySQL 插入emoji表情错误的解决方案，Incorrect string value: '\xF0\x9F\x98\x84’ 原因： mysql的UTF-8只支持三个字节的存储，而一般字符是三个字节，但是emoji表情是4个字节，所以存储不了。 解决方案： 第一步：在有表情的字段上就应该这样做,将该字段设置为utf8mb4 ALTER TABLE table_na
谈谈多线程中的Future
dev晴天的博客
02-23 2014
为啥会有Future 常见的开启线程方式有两种： 重写Thread的run方法，调用start开启线程。 给Thread传参Runnable实现类对象(需要实现run方法),调用start开启线程。 但是这两种方式都有局限性，那就是run方法虽然运行在子线程中，但是我们无法得知run方法执行的结果。这时又出现了几个相关类Future、FutureTask、Callable。这几个类结合Thread就可实现获取其他线程中执行方法后的返回结果。 相关简介 Future相关主要有两个类FutureTask和C
数据结构之栈
dev晴天的博客
02-05 186
我们都知道栈是一种比较重要的数据结构然而他重要在哪呢？有何用处？如何设计我们自己的栈？本章将会探究解开栈的神秘面纱。 本文要点 了解栈 1 概念： 一种后进先出（LIFO）的数据结构，属于线性数据结构。 2 特点： 其实相对于数组来说栈操作的是数组的子集。只需要对数组添加约束便形成栈的特有功能。 添加约束： 1 规定只能向栈的末尾添加元素 2 规定只能从栈的末尾（栈顶）取出元素 ps：通...
【计算机网络3】数据链路层
dev晴天的博客
08-20 1106
物理层的作用正是要尽可能地屏蔽掉不同传输媒体和通信手段的差异。使物理层上面的数据链路层感觉不到这些差异，这样就可使数据链路层只需要考虑如何完成本层的协议和服务，而不必考虑网络具体的传输媒体和通信手段是什么。 一、点对点信道 点对点信道使用协议 链路&数据链路 帧 数据链路层三个问题 二、广播信道 广播信道使用的协议 局域网 以太网 End 待续。。。。 ...
智慧建造总体策划方案（76页）.pptx
11-02
智慧建造总体策划方案（76页）
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件
最新发布
11-02
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件，已在 windows、deepin linux 和树莓派上测试！
Java异常体系详解
Java异常是程序运行时发生的问题，这些异常分为两种主要类型：Error和Exception。Error通常表示严重的系统级问题，而Exception是程序可以预见和处理的异常情况。 1. **算术异常类：ArithmeticExecption** - 当执行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值