Java基础整理（十四）

最新推荐文章于 2024-10-12 22:35:37 发布

李同学向前冲

最新推荐文章于 2024-10-12 22:35:37 发布

阅读量70

点赞数

分类专栏： Java基础文章标签： java 后端

本文链接：https://blog.csdn.net/qq_43201722/article/details/121395425

版权

Java基础专栏收录该内容

26 篇文章 0 订阅

订阅专栏

异常处理

异常指程序运行中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。

异常发生在程序运行期间，它影响了正常的程序执行流程。

异常是由JVM打印的

异常在java中以类的形式存在，每一个异常类都可以创建异常对象

public class Demo{

    public static void main(String[] args) {

        NumberFormatException nfe = new NumberFormatException("数字格式化异常");
        System.out.println(nfe); //java.lang.NumberFormatException: 数字格式化异常

    }
}

public class Demo{

    public static void main(String[] args) {

        int a = 10;
        int b = 0;
        //JVM在执行到此处时，会new异常对象:new ArithmeticException("/ by zero")
        //JVM将new的异常对象抛出，打印输出信息到控制台
        int c = a/b;
    }
}

简单分类：
- 编译时异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略
- 运行时异常：运行时异常是可能被程序员避免地异常。与检查性异常相反，运行时异常可以在编译时被忽略
- 错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到
==注：==编译时异常不代表异常是在编译时发生，而是必须在编写程序时预先处理这种异常，如果不处理，编译器报错。

所有异常都是发生在运行阶段的
异常体系结构

在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception

在这里插入图片描述

Error

Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关
- Java虚拟机运行错误，当JVM不再有继续执行操作所需要的内存资源时，将出现OutOfMemoryError。这些异常发生时，JVM一般都会选择线程终止
- 还有发生在虚拟机试图执行应用时，如类定义错误、链接错误。这些错误都是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的错误
Exception

在Exception分支有一个重要的子类RuntimeException（运行时异常）、ArrayIndexOutofBoundsException（数组下标越界）、NullPointerException（空指针异常）、ArithmeticException（算数异常）、MissingResourceException（丢失资源）、ClassNotFoundException（找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获异常，也可以不处理

这些异常一般都是由程序逻辑引起的，应从逻辑角度尽可能避免此类异常的发生
Error和Exception的区别

Error通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，JVM一般会选择终止线程，直接退出

Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能地去处理这些异常
java对异常处理的方式有两种
- 第一种在方法声明使用throws，抛给上一级（谁调用我，抛给谁，这个人依然有两种处理方式）
- 第二种try…catch语句异常捕捉（自己处理，调用我的人察觉不到异常存在）
java异常发生之后如果一直向上抛，最终会抛给main方法，main方法继续向上抛，抛给了调用者JVM，JVM知道这个异常发生，就会终止java程序

分析以下代码为什么报错？

public class Demo{
    public  static void main(String[] args){
    
        //doSome()方法声明位置上有：throws ClassNotFoundException
        //我们在调用doSome()方法的时候必须对这个异常进行预处理
        //如果不处理，编译器就会报错
        doSmoe();
    }
    
    public static void doSome() throws ClassNotFoundException{
        System.out.println("doSome!!");
    }
}

第一种处理方法（向上抛异常传给调用者）

public class Demo{
    public  static void main(String[] args) throws ClassNotFoundException {

        doSmoe();
    }
    
    public static void doSome() throws ClassNotFoundException{
        System.out.println("doSome!!");
    }
}

第二种处理方法（异常拦截自己处理调用者不知道）

public class Demo{
    public  static void main(String[] args){
        try{
            doSmoe();
        }catch(ClassNotFoundException e){
            //e引用保存的内存地址是那个new出来异常对象的内存地址
            e.printStackTrace();
        }
    }
    
    public static void doSome() throws ClassNotFoundException{
        System.out.println("doSome!!");
    }
}

try catch finally throw throws 关键字的应用

当要捕获多个异常时，可以定义多个catch，但要异常要从小到大排列，其中finally是一定会执行的语句，无论是否捕获到异常

    public static void main(String[] args)  {
       
        int a=1;
        int b=0;

        try {
            System.out.println(a/b);
        } catch (Error e) {
            System.out.println("Error");
        }catch(Exception e){
            System.out.println("Exception");
        }catch(Throwable t){
            System.out.println("Throwable");
        } finally {
            System.out.println("finally");
        }
    }
//Exception
//finally

throw主动抛出异常，一般在方法中使用。throws一般在方法上使用，方法抛出

public class Demo {

    public static void main(String[] args)  {

        try {
            new Demo().test(1,0);
        } catch (ArithmeticException e) { //捕获方法抛出的异常
            e.printStackTrace();
        }

    }

    public void test(int a,int b) throws ArithmeticException{ //处理不了抛出给调用者
        if(b==0){
            throw new ArithmeticException();
        }
    }

}

==注：==只要异常没有捕捉，采用上报的方式，此方法后续代码不会执行

try语句块中的某一行出现异常，该行后续代码不会执行

try…catch捕捉异常后，后续代码可以执行

throws后面可以写多个异常，可以用逗号隔开

public static void main(String[] args) throws ClassCastException, FileNotFoundException{
}

Java8新特性

try{
}catch(FileNotFoundException | ArithmeticException | NullPointerException e){
      
}

异常对象两个重要方法

**getMessage()**获取异常的简单描述信息(构造方法上面的String参数)

NullPointerException e = new NullPointerException("空指针异常"); //只是new了一个java对象
        String s = e.getMessage();
        System.out.println(s); //空指针异常

**printStackTrace()**打印异常追踪的堆栈信息（开发中常用）

NullPointerException e = new NullPointerException("空指针异常");
        e.printStackTrace();
//java.lang.NullPointerException: 空指针异常
//	at com.bobo.base.Demo.main(Demo.java:14)

java后台打印异常堆栈追踪信息的时候，采用了异步线程的方式打印

自定义异常

用户可以自定义异常。用户自定义异常类，只需继承Exception类即可。

创建自定义异常大体步骤：

创建自定义异常类继承类Exception或者RuntimeException
提供两个构造方法，一个无参数的，一个带有String参数的
在方法中通过throw关键字抛出异常
如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明出通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
在出现异常方法的调用者中捕获并处理异常

  public class Demo {
  
      public static void main(String[] args)  {
  
          try {
              new Demo().test(11);
          } catch (Exception e) {
              System.out.println("MyException："+e);
          }
  
      }
  
      public void test(int a) throws MyException{
  
          if(a>10){
              throw new MyException(a);
          }
      }
  
  }
  
  public class MyException extends Exception {
  
      private int detail;
  
      public MyException(int a){
          this.detail=a;
      }
  
  
      //打印异常信息
      @Override
      public String toString() {
          return "MyException{" +
                  "detail=" + detail +
                  '}';
      }
  }

final finally finalize
- final关键字
  - final修饰的类无法继承
  - final修饰的方法无法覆盖
  - final修饰的变量不能重新赋值
- finally关键字
  - 和try联合使用
  - finally语句块中的代码是必须执行的
- finalize标识符
  - 是一个Object类中的方法名
  - 由垃圾处理器GC负责调用
经验总结
- 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
- 一般不建议在main方法使用throws，如果异常发生，会抛给JVM，而异常处理机制就是为了程序的健壮性。
- 在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常
- 对于不确定的代码，也可以加上try-catch，处理潜在的异常
- 尽量去处理异常，切忌知识简单地调用printStackTrace()去打印输出
- 具体如何处理异常，要根据不同地业务需求和异常类型去决定
- 尽量添加finally语句块去释放占用的资源
- try不能单独使用，可以和finally或联合使用，当只有try和finally时，由于异常未捕获，需要抛出异常
- 重写之后的方法不能比重写之前的方法抛出更多的异常，可以更少或相同