异常

定义：

• （狭义）异常就是在系统运行过程中出现的问题。即程序在执行过程中出现的不正常的情况，这些情况很多不靠代码解决。
• （广义）开发过程中的语法或者逻辑错误导致的异常。
  JAVA中讨论的异常皆为（狭义）。

分类：

• Error–虚拟机无法解决的严重问题。

这类问题不能通过代码解决，是硬件问题。
例子.jvm内存不足时异常.

public static void main(String[] args) {
        List list = new ArrayList<>() ;
        while(true){
            list.add(new Random());//随机加数
      }

• Exception–其他因为编程错误或者偶然因素导致的一般性问题.(可以用针对性的代码处理.)

  • 例子.空指针访问

   public static void main(String[] args) {
          String s = null;
          s.length();
      }
  //异常结果
                                            (异常类型--空指针异常)
      Exception in thread "main" java.lang.NullPointerException
      at day01.ErrorDemo.main(ErrorDemo.java:65)
  

  • 例子.数组下标越界

      public static void main(String[] args) {
          int[] a = new int[3];
          a[3]=1;
      }
  //异常结果
  										(异常类型--数组下标越界)
  Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
  	at day01.ErrorDemo.main(ErrorDemo.java:19)
  

  • 例子.算数异常

   public static void main(String[] args) {
          int a = 10;
          int b = 0;
          System.out.println(a/b);
      }
  //异常结果
                                           (异常类型--算数异常)          (异常原因)
          Exception in thread "main" java.lang.ArithmeticException: / by zero
  	at day01.ErrorDemo.main(ErrorDemo.java:19)
  	                          (异常位置)//异常的位置和原因可能不在同一个地方
  

  • 例子.类型转换异常

  public static void main(String[] args) {
          String s = "gogogo";
          Object obj = s;
          if (obj instanceof Integer){
              Integer i = (Integer) obj;
          }
  //异常结果
                                             (异常类型--类型转换异常--将实例转化为不属于对象的子类.)
          Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
  	at day01.ErrorDemo.main(ErrorDemo.java:39)
  

  • 数字格式化异常

  public static void main(String[] args) {
          int i = Integer.parseInt("fight");//parse()将字符串参数解析为带符号的十进制整数。
      }
  //异常结果
  Exception in thread "main" java.lang.NumberFormatException: For input string: "fight"
      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 day01.ErrorDemo.main(ErrorDemo.java:53)
  

解决方法

• 虚拟机处理

  如果程序员对异常不做处理那么虚拟机就会直接结束程序运行，给出异常信息。

  Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
  	at day01.ErrorDemo.main(ErrorDemo.java:19)
  

• 编写程序时，考虑到异常的检测捕获、声明、抛出。

体系

• Throwable是所有异常的祖先类，它有两个子类：Exception类、Error类。

  • Error表示错误，往往是硬件问题，程序中并不做处理。
  • Exception 表示“异常”，是所有“异常类”的父类（程序开发人员所关注的异常）。

• 捕获异常最理想的是在编译期间，但有的异常只有在运行时才会发生。比如：除数为0，数组下标越界等。因此，异常又分为：运行时异常、编译时异常。

  • 运行时异常

    • 程序运行时，才会抛出的异常，也叫非受检异常。

    • 举例：

      //数组下标越界
      /*                                           (异常类型--数组下标越界)
              Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
      	at day01.ErrorDemo.main(ErrorDemo.java:19)
          public static void main(String[] args) {
              int[] a = new int[3];
              a[3]=1;
          }
      
          //算数异常
          /*                                          (异常类型--算数异常)               (异常原因)
              Exception in thread "main" java.lang.ArithmeticException: / by zero
      	at day01.ErrorDemo.main(ErrorDemo.java:19)
      	                                    (异常位置)//异常的位置和原因可能不在同一个地方
          public static void main(String[] args) {
              int a = 10;
              int b = 0;
              System.out.println(a/b);
          }*/
      
          //类型转换异常
          /*                                        (异常类型--类型转换异常--将实例转化为不属于对象的子类.)
              Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
      	at day01.ErrorDemo.main(ErrorDemo.java:39)
      
      
          public static void main(String[] args) {
              String s = "gogogo";
              Object obj = s;
              if (obj instanceof Integer){
                  Integer i = (Integer) obj;
              }
      
          }*/
      
          //数字格式化异常
          /*                                      (异常类型--数字格式化异常)
          Exception in thread "main" java.lang.NumberFormatException: For input string: "fight"
          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 day01.ErrorDemo.main(ErrorDemo.java:53)
      
          public static void main(String[] args) {
              int i = Integer.parseInt("fight");//parse()将字符串参数解析为带符号的十进制整数。
          }*/
      
          //空指针异常
         /*                                          (异常类型--空指针异常)
          Exception in thread "main" java.lang.NullPointerException
          at day01.ErrorDemo.main(ErrorDemo.java:65)
          public static void main(String[] args) {
              String s = null;
              s.length();
          }*/
      

  • 编译时异常

    • 除去运行时异常，其余都是编译时异常，也叫检测异常、受检异常。
    • 举例：IOException、SQLException

  • 体系图

  

异常处理

• Java的异常处理是通过5个关键字来实现的：try、catch、 finally、throw、throws

• 捕获异常的相关函数。(写法3中有例子。)
  • getMessage（）—这是程序员用于获取异常信息的函数。
  • printStackTrace（）—这是将异常信息打印到控制台的函数（更直接）。

基本语法

try{

可能会发生异常的代码

}catch(异常类型 引用名){

​ 异常处理代码

}finally{

必须执行代码

}

• try
  try块中的任何一条代码异常，try块中剩余的代码便不会被执行，程序将跳转至catch块（异常处理块）中，随时会中断。
• catch
  把捕获到类型匹配的异常进行处理，保证程序的运行。catch块里往往放着异常处理函数。
• finally
  finally块中的代码，是程序无论何时必须被执行的，一个try块只能对应一个finally块

1. • 写法1

   public static void main(String[] args) {
           int a = 10;
           int b = 0;
           try{
               System.out.println(a/b);//可能出现异常的语句。
           }catch (ArithmeticException p){//在此处填上异常的类型对象
               System.out.println("除数不能为0.");//异常后语句
           }
   
       }
   

   • 写法2

   // try{}里面嵌套try{}catch(){}
           try{
               int a = 10;
               int b = 2;
               System.out.println(a/b);
               try{
                   int[] a1 = new int[3];
                   a1[3]=1;
               }catch(ArrayIndexOutOfBoundsException A1){
                   System.out.println("异常:数组下标越界.");
               }
   
           }catch(ArithmeticException A2){
               System.out.println("异常:算数异常.");
           }
   

   • 写法3

    //一个try{}对应多个catch(){}.
           try{
               //算数异常
               int a = 10;
               int b = 2;
               System.out.println(a/b);
               //数组下标越界异常
               int[] a1 = new int[3];
               a1[3]=1;
           }catch(ArithmeticException A2){
               System.out.println("异常:算数异常.");
           }*//*catch(ArrayIndexOutOfBoundsException A1){
               System.out.println("异常:数组下标越界.");
           }*//*catch(Exception e){
               System.out.println("系统忙请稍后再试.");//给用户的基本提示.
               System.out.println(e.getMessage());//打印简略异常信息 , 后期可用第三方日志组件向文件输出信息.
               e.printStackTrace();//打印异常详细信息到控制台.
           }*/
   

   • 写法4

    public static int finaldemo(){
           try{
               int a = 10;
               int b = 0;
               System.out.println(a/b);
               return 3;
           }catch(ArithmeticException A2){
               System.out.println("异常:算数异常.");
               return 0;
   
           }finally{           //finally里面的语句块必须被执行.
               System.out.println("aaaaaa");
               return 1;//如果fianlly里面有return,程序到此结束
   
           }
   
           //System.out.println("bbbbbb");如果前面有return该语句会被跳过.
       }
   

throws关键字

• throws关键字可以修饰方法。子类重写父类中的方法时，子类方法不能抛出比父类类型更大的异常。
• 用该关键字声明该方法不处理异常，而交给方法调用处处理，调用处若不处理，也可用throws声明。
• throws声明的是运行时异常，调用时可不处理异常。
• throws后面可以跟多个异常

public static void main(String[] args) {
        try {
            test();//方法调用处
        }catch (ArithmeticException a){
            System.out.println("异常类型:算数异常.");
        }
    }
    public static void test()throws ArithmeticException{
        int a = 10;
        int b = 0;
        System.out.println(a/b);
    }

throw关键字

• throw关键字修饰的是对象，该关键字用于显式抛出异常，抛出的是异常类的实例化对象。
• 在创建对象的构造方法中可传入异常的原因。

public class Demo6 {
    public static void main(String[] args) {
        try{
            int a = test(-3);
            System.out.println(a);
        }catch(RuntimeException r){
            System.out.println(r.getMessage());
        }


    }
    public static int test(int a){

        if (a < 0){
            throw new RuntimeException("传入的值有误");//在程序运行时,主动抛出异常对象,在构造方法中传入异常的原因
        }else{
            return a;
        }


    }
}

自定义异常

• 使用前提：当已知的异常不能满足用户需求时，可以自定义异常。
• 自定义异常时，如果是编译时异常，就继承Exception，运行时异常，就继承RunTimeException

public class SanJiaoXing {
    public static void main(String[] args) {
        SanJiaoXing s = new SanJiaoXing();
        try {
            System.out.println(s.pan_duan(1.3,2.6,9.9));	//调用处
        } catch (SanJiaoExp sanJiaoExp) {
            sanJiaoExp.printStackTrace();
        }
    }
    public String pan_duan(double a,double b,double c) throws SanJiaoExp {

        if(a+b>c&&a+c>b&&b+c>a){
            return "这些边可以构成三角形";
        }else{
            throw new SanJiaoExp("这些边不能构成三角形.");
        }

    }
}

//自定义异常（三角形）
public class SanJiaoExp extends Exception {
    public SanJiaoExp(String message) {
        super(message);//调用Exception的构造方法
    }

}

原文链接:https://blog.csdn.net/qq_45785542/article/details/109775370