java runtime 以root运行

转载

mob64ca140ce312 2025-01-03 07:25:44

文章标签 java jvm 开发语言 System 异常处理机制 文章分类 Java 后端开发

异常处理

1.1 Java异常处理机制

1.2 异常处理机制中的finally

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

1.4 throw关键字

1.5 throws关键字

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

1.7 Java异常可以分为可检测异常，非检测异常

1.8 常见的RuntimeException子类

1.9 自定义异常

1.10 总结

异常处理

1.1 Java异常处理机制

java 中所有错误的超类为 :Throwable 。其下有两个子类 :Error 和 Exception

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

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

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

```java
 package exception;/**
  * 异常处理机制中的try-catch
  * 语法:
  * try{
  *     代码片段...
  * }catch(XXXException e){
  *     出现错误后的补救措施(B计划)
  * }
  */
 public class TryCatchDemo {
     public static void main(String[] args) {
         System.out.println("程序开始了...");
         /*
             try{}语句块不能单独写，后面要么跟catch语句块要么跟finally语句块            异常处理机制关注的是:明知道程序可能出现某种错误，但是该错误无法通过修改逻辑
             完全规避掉时，我们会使用异常处理机制，在出现该错误是提供一种补救办法。
             凡是能通过逻辑避免的错误都属于bug！就应当通过逻辑去避免!
          */
         try {
 //            String str = null;
 //            String str = "";
             String str = "a";
         /*
             若str=null的情况
             当JVM执行到下面代码时:str.length()会出现空指针，此时虚拟机就会根据该情况
             实例化一个对应的异常实例出来，即:空指针异常实例 NullPointerException实例
             然后将程序从一开始执行到报错这句话的过程设置到该异常实例中，此时该异常通过
             类型名字可以表达出现了什么错误，并将来可以通过输出错误信息来得知错误出现在那里
             虚拟机会将该异常抛出
             当某句代码抛出了一个异常时，JVM会做如下操作:
             1:检查报错这句话是否有被异常处理机制控制(有没有try-catch)
               如果有，则执行对应的catch操作，如果没有catch可以捕获该异常则视为没有
               异常处理动作
             2:如果没有异常处理，则异常会被抛出当当前代码所在的方法之外由调用当前方法的
               代码片段处理该异常
          */
             System.out.println(str.length());//抛出空指针异常
             System.out.println(str.charAt(0));
             System.out.println(Integer.parseInt(str));
             /*
                 当try中某句代码报错后，就会跳出try执行下面对应的catch块，执行后就会
                 退出catch继续向后执行。因此try语句块中报错代码以下的内容都不会被执行
              */
             System.out.println("!!!!!!!!!!!!!!");
 //        }catch(NullPointerException e){
 //            //这里实际开发中是写补救措施的，通常也会将异常信息输出便于debug
 //            System.out.println("出现了空指针，并解决了!");
 //        }catch(StringIndexOutOfBoundsException e){
 //            System.out.println("处理字符串下标越界问题!");
 //        }
         /*
             当try语句块中可能出现的几种不同异常对应的处理办法相同时，可以采取合并
             catch的做法，用同一个catch来捕获这几种可能出现的异常，而执行措施使用
             同一个。
          */
         }catch(NullPointerException|StringIndexOutOfBoundsException e){
             System.out.println("处理空指针或下标越界!");
         /*
             当catch捕获某个超类型异常时，那么try语句块中出现它类型异常时都可以被这个
             catch块捕获并处理。            如果多个catch捕获的异常之间存在继承关系时，一定是子类异常在上超类异常在下
          */
         }catch(Exception e){
             System.out.println("反正就是出了个错!");
         }
         System.out.println("程序结束了...");
     }
 }

1.2 异常处理机制中的finally

- finally块定义在异常处理机制中的最后一块。它可以直接跟在try之后，或者最后一个catch之后。
- finally可以保证只要程序执行到了try语句块中，无论try语句块中的代码是否出现异常，最终finally都必定执行。
- finally通常用来做释放资源这类操作。

``java
 package exception;/**
  * finally块
  * finally块是异常处理机制中的最后一块，它可以直接跟在try语句块之后或者最后一个catch块
  * 之后。
  * finally可以保证只要程序执行到try语句块中，无论try语句块中的代码是否出现异常，finally
  * 都【必定执行】!
  * 通常finally块用于做释放资源这类操作，比如IO操作后的关闭流动作就非常适合在finally中进行
  */
 public class FinallyDemo {
     public static void main(String[] args) {
         System.out.println("程序开始了...");
         try{
             String str = "abc";
             System.out.println(str.length());
             return;
         }catch(Exception e){
             System.out.println("出错了，并处理了");
         }finally{
             System.out.println("finally中的代码执行了!");
         }
         System.out.println("程序结束了");
     }
 }

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

public class FinallyDemo2 {
     public static void main(String[] args) {
         FileOutputStream fos = null;
         try {
             fos = new FileOutputStream("fos.dat");
             fos.write(1);
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 if(fos!=null) {
                     fos.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
 }
```java
 语法:
 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案例的代码样子。

1.4 throw关键字

throw用来对外主动抛出一个异常，通常下面两种情况我们主动对外抛出异常:
- 1:当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。
 - 2:程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。```java
 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;
     }
 }
 ``````java
 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());
     }
 }
 ```

1.5 throws关键字

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

```java
 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声明该异常的抛出给调用者解决。具体选取那种取决于异常处理的责任问题。

```java
 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("程序结束了...");
     }
 }

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

```java
 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 {}
 }
 ```

1.7 Java异常可以分为可检测异常，非检测异常

- 可检测异常：可检测异常经编译器验证，对于声明抛出异常的任何方法，编译器将强制执行处理或声明规则，不捕捉这个异常，编译器就通不过，不允许编译。
- 非检测异常：非检测异常不遵循处理或者声明规则。在产生此类异常时，不一定非要采取任何适当操作，编译器不会检查是否已经解决了这样一个异常
- RuntimeException 类属于非检测异常，因为普通JVM操作引起的运行时异常随时可能发生，此类异常一般是由特定操作引发。但这些操作在java应用程序中会频繁出现。因此它们不受编译器检查与处理或声明规则的限制。

1.8 常见的RuntimeException子类

- IllegalArgumentException：抛出的异常表明向方法传递了一个不合法或不正确的参数
- NullPointerException：当应用程序试图在需要对象的地方使用 null 时，抛出该异常
- ArrayIndexOutOfBoundsException：当使用的数组下标超出数组允许范围时，抛出该异常
- ClassCastException：当试图将对象强制转换为不是实例的子类时，抛出该异常
- NumberFormatException：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。

```java
 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("程序结束了");
     }
 }

1.9 自定义异常

自定义异常通常用来定义那些业务上的异常问题。

定义自定义异常需要注意以下问题:

- 异常的类名要做到见名知义
- 需要是Exception的子类
- 提供超类异常提供的所有种类构造器

```java
 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);
     }
 }
 ``````java
 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;
     }
 }
 ``````JAVA
 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("程序结束了...");
     }
 }

```

1.10 总结

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

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

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：jquery文字展开收缩效果

下一篇：java 关键字获取枚举

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯