Java中的异常详解

绝地灬酷狼 2022-02-14 05:46 183阅读 0赞

### 文章目录 ###

*  Java中的异常详解
 *   *   *  前言
         *  概述
         *   *  Java中的异常：
             *  常见异常：
         *  Throwable类
         *   *  成员方法:
             *  Error和Exception
         *  Exception类
         *  异常处理
         *   *  分析
             *  处理方式
         *  Throws和Throw
         *   *  throws关键字
             *  throw关键字
             *  throws和throw的区别
         *  finally关键字
         *  自定义异常

# Java中的异常详解 #

--------------------

### 前言 ###

生活中的异常：

1.  每天上班坐公交车去，正常的话半个小时，但是有时候会出现堵车(一定会出现的)，或者遇到交通事故等，就有可能造成上班迟到的情况，这就是一种异常情况。
2.  睡觉的时候，睡的正香，突然一个电话过来，被吵醒了。
3.  在大街上走着，突然被绊倒了。

### 概述 ###

#### Java中的异常： ####

*  异常是指在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序。简单来说就是程序出现了不正常的情况。
 *  异常本质就是Java当中对可能出现的问题进行描述的一种对象体现。

#### 常见异常： ####

*  除数不能为0异常（ArithmeticException）
 *  空指针异常（NullPointException）
 *  数组越界异常（ArrayIndexOutOfBoundsException）
 *  类型转换异常（ClassCastException）

--------------------

### Throwable类 ###

> Throwable 类是 Java 语言中所有错误或异常的超类。

![1556195855322][]

#### 成员方法: ####

*  public String getMessage()：返回此 throwable 的详细消息字符串
 *  public String toString()：获取异常类名和异常信息。
 *  public void printStackTrace()：获取异常类名和异常信息，以及异常出现在程序的位置。
 *  public void printStackTrace(PrintStream s)：通常用该方法将异常内容保存在日志文件中，以便查阅。

#### Error和Exception ####

1.  Error：称为错误，由Java虚拟机生成并抛出，程序对其不做处理。
2.  Exception：所有异常类的父类，其子类对应了各种各样可能出现的异常事件，一般需要用户显示的声明或捕获。

--------------------

### Exception类 ###

> 所有异常类的父类，其子类对应了各种各样可能出现的异常事件，一般需要用户显示的声明或捕获。

运行时期异常(RuntimeException)：

*  运行时期异常，又称为非受检异常，RuntimeException及其所有子类都是运行时期异常。

编译时期异常：

*  不是继承自RuntimeException的Exception的子类都成为编译时期异常

--------------------

### 异常处理 ###

> 如果我们不做任何处理，异常将会交由虚拟机来处理。
> 
> 虚拟机的处理方式：
> 
>  *  把异常的名称，异常出现的位置，异常原因，等信息输出打印在控制台，并同时将程序停止执行。

思考：

在实际开发当中显然直接将应用程序挂掉的这种方式是不可取的，就算程序有异常，我们也理应让程序继续执行下去，提高用户体验。那我们又该怎么做呢？

#### 分析 ####

异常的执行流程:

1.  程序执行到错误行,系统会创建一个异常对象,并且抛给我们
    
    ArithmeticException exp = new ArithmeticException("/by zero");
    
     throw exp;
2.  程序进入catch块进行逐个匹配,匹配成功,程序执行catch块代码
    
    ArithmeticException ae = exp;
    
     Exception e = exp;
3.  匹配失败,交给jvm处理

jvm默认是如何处理异常的?

1.  打印错误信息
    
    a.异常名称 java.lang.ArithmeticException
    
    b.异常的消息 / by zero
    
    c.异常所发生的方法位置 at com.sxt.exceptiondemo.ExceptionDemo02.main
    
    d.异常所在Java文件中 ExceptionDemo02.java
    
    e.异常发生行号 14
2.  终止程序
    
    System.exit(0);

处理异常的标准方式:

1.  能够显示处理的尽量显示处理,提高程序的可读性。
2.  但是一定要在异常处理的最后加上 父类Exception处理。

#### 处理方式 ####

1.  try…catch…finally
2.  throws抛出异常

*  try…catch…finally
    
     *  try…catch…finally的处理格式：  
        异常处理的格式：  
        try\{  
        //放置程序可能出现问题的代码  
        \}catch(异常类 异常名)\{  
        //这里放置异常处理的代码  
        \} finally\{  
        //释放资源  
        \}
     *  多个异常的处理  
        格式：try\{  
        …  
        \}catch(异常类名 变量名) \{  
        …  
        \}catch(异常类名 变量名) \{  
        …  
        \} catch…
        
        排列catch 语句的顺序：
        
        1.  先子类后父类
        2.  发生异常时按顺序逐个匹配
        3.  只执行第一个与异常类型匹配的catch语句

### Throws和Throw ###

#### throws关键字 ####

*  概述：在定义一个方法的时候可以使用throws关键字声明，使用throws声明的方法表示此方法不处理异常，而交给方法的调用者进行处理。
 *  格式： \[修饰符\] 返回值类型 方法名(参数列表) \[throws 异常类1,异常类2…\]\{  
    \}

> 注意:  
> 1、如果一个方法声明的是编译时期异常，则在调用这个方法之处必须处置这个异常（谁调用谁处理）。  
> 2、重写一个方法时，它所声明的异常范围不能被扩大

public static int calc() throws ArithmeticException{ 
                   int a = 10;
                   int b = 0;
                   int result = a/b;
                   return result;
           }

#### throw关键字 ####

*  在方法代码中主动抛出一个异常。如果方法代码中自行抛出的异常是编译时期异常，则这个方法要用throw关键字声明这个异常。

public static void method2() throws ArithmeticException { 
                   int a = 10;
                   int b = 0;
                   if (b == 0) { 
                       // throw
                           throw new ArithmeticException("除数为0了！");
                   }
                   System.out.println(a/b);
           }

#### throws和throw的区别 ####

1.  throws用在方法声明后面，跟的是异常类名，throw用在方法体内，跟的是异常对象名。
2.  throws可以跟多个异常类名，用逗号隔开，throw只能抛出一个异常对象名。
3.  throws表示抛出异常，由该方法的调用者来处理，throw表示抛出异常，由方法体内的语句处理。
4.  throws表示出现异常的一种可能性，并不一定会发生这些异常，throw则是抛出了异常，执行throw则一定抛出了某种异常。

### finally关键字 ###

> finally修饰的代码块一定会被执行，除非在执行到finally之前程序异常退出或者调用了系统退出的方法。
> 
> finally用于释放资源，在IO流操作和数据库操作中会见到。

注意：

finally碰到return时finally一定会执行，那执行顺序?

public class ExceptionDemo09 { 
    	public static void main(String[] args) { 
    
    		System.out.println(test()); // 4 3
    	}
    
    	public static int test() { 
    		int x = 1;
    		try { 
    			System.out.println(x++ / 0); // 2
    		} catch (Exception e) { 
    			x++; //
    			return x; // return 3;
    		} finally { 
    			++x; // 4
    			System.out.println(x); // 4
    		}
    		return x;
    	}
    }

分析：

在try语句中，在执行return语句时，要返回的结果已经准备好了，就在此时，程序转到finally执行了。

在转去之前，try中先把要返回的结果存放到不同于x的局部变量中去，执行完finally之后，在从中取出返回结果。

因此，即使finally中对变量x进行了改变，但是不会影响返回结果。它应该使用栈保存返回值。

--------------------

### 自定义异常 ###

> 在工作中有许多异常需要自己写。那如何写一个异常呢？

*  编写一个分数必须在0-100分之间的异常，并且使用这个异常。

步骤：

*  定义一个异常继承Throwable或者Exception或者RuntimeException
 *  编写构造方法
    
     *  带参
     *  无参

public class ExceptionDemo { 
           public static void main(String[] args) { 
                   Scanner input = new Scanner(System.in);
                   System.out.println("请输入一个分数:");
                   double score = input.nextDouble();
                   Teacher teacher = new Teacher();
                   try { 
                           System.out.println(teacher.isBetween0To100(score) ? "分数合法" : "分数不合法");
                   } catch (ScoreException e) { 
    // e.printStackTrace();
                           System.err.println(e.getMessage());
                   } catch (Exception e) { 
                           e.printStackTrace();
                   } finally { 
                           input.close();
                   }
                   System.out.println("分数批改完毕!");
                                   
           }
    }
    
    class ScoreException extends Exception{ 
           
           public ScoreException(){ }
           
           public ScoreException(String message) { 
                   super(message);
           }
    }
    
    class Teacher{ 
           
           public boolean isBetween0To100(double score) throws ScoreException{ 
                   if (score > 100 || score < 0) { 
                           throw new ScoreException("分数必须在0-100分之间！！！");
                   }
                   return true;
           }
    }

--------------------

以上

@Fzxey

[1556195855322]: /images/20220214/c29ac806bd0742e4aa1badaeb77dd82f.png