JAVA深化篇_2——异常机制

在具体谈论java异常之前，我先简单给大家介绍一下java异常机制的概念，以及异常机制的用途与使用环境。

首先我们先提一下异常概念：

异常（Exception）的概念

异常指程序运行过程中出现的非正常现象，例如除数为零、需要处理的文件不存在、数组下标越界等。

在Java的异常处理机制中，引进了很多用来描述和处理异常的类，称为异常类。异常类定义中包含了该类异常的信息和对异常进行处理的方法。

其实呢，异常的本质就是：

异常机制本质

当程序出现异常，程序安全的退出、处理完后继续执行的机制

我们开始看我们的第一个异常对象，并分析一下异常机制是如何工作的。

下面我们举例分析一个具体的java异常

【示例】异常的分析

 public class Test {
   public static void main(String[] args) {
     System.out.println("111");
     int a = 1/0;
     System.out.println("222");
    }
 }

执行结果如图所示：

根据结果，我们可以看到执行“1/0”时发生了异常，程序终止了，没有执行后面的打印“222”的动作。

如果我们使用try-catch来处理，程序遇到异常可以正常的处理，处理完成后，程序继续往下执行：

 public class Test {
   public static void main(String[] args) {
     System.out.println("111");
     try {
       int a = 1/0;
      } catch (Exception e) {
       e.printStackTrace();
      }
     System.out.println("222");
    }
 }

 执行结果如下：

程序在执行“1/0”仍然遇到异常，然后进行try-catch处理。处理完毕后，程序继续往下执行，打印了“222”内容。

Java是采用面向对象的方式来处理异常的。处理过程：

• 抛出异常：在执行一个方法时，如果发生异常，则这个方法生成代表该异常的一个对象，停止当前执行路径，并把异常对象提交给JRE。

• 捕获异常：JRE得到该异常后，寻找相应的代码来处理该异常。JRE在方法的调用栈中查找，从生成异常的方法开始回溯，直到找到相应的异常处理代码为止。

 异常分类：

Java中定义了很多异常类，这些类对应了各种各样可能出现的异常事件，所有异常对象都是派生于Throwable类的一个实例。如果内置的异常类不能够满足需要，还可以创建自己的异常类。

Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception。

1.Error（错误）

Error是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

Error表明系统JVM已经处于不可恢复的崩溃状态中。

2.Exception（异常）

Exception是程序本身能够处理的异常。

Exception类是所有异常类的父类，其子类对应了各种各样可能出现的异常事件。 通常Java的异常可分为：

1. RuntimeException 运行时异常

2. CheckedException 已检查异常

1.RuntimeException运行时异常  

派生于RuntimeException的异常，如被 0 除、数组下标越界、空指针等，其产生比较频繁，处理麻烦，如果显式的声明或捕获将会对程序可读性和运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序。

编译器不处理RuntimeException, 程序员需要增加“逻辑处理来避免这些异常”。

ArithmeticException异常：试图除以0

public class Test3 {
     public static void main(String[ ] args) {
         int b=0;
         System.out.println(1/b);
     }
 }

执行结果如图所示：

解决如上异常需要修改代码：

 public class Test3 {
     public static void main(String[ ] args) {
         int b=0;
         if(b!=0){
             System.out.println(1/b);
         }
     }
 }

 ​NullPointerException异常

 public class Test4 {
     public static void main(String[ ] args) {
         String str=null;
         System.out.println(str.charAt(0));
     }
 }

 ​执行结果如图所示：

解决如上异常需要修改代码：

 public class Test3 {
     public static void main(String[ ] args) {
         int b=0;
         if(b!=0){
             System.out.println(1/b);
         }
     }
 }

 ​

ClassCastException异常

 class Animal{
     
 }
 class Dog extends Animal{
     
 }
 class Cat extends Animal{
     
 }
 public class Test5 {
     public static void main(String[ ] args) {
         Animal a=new Dog();
         Cat c=(Cat)a;
     }
 }

执行结果如图所示：

解决ClassCastException的典型方式：

 public class Test5 {
     public static void main(String[ ] args) {
         Animal a = new Dog();
         if (a instanceof Cat) {
             Cat c = (Cat) a;
         }
     }
 }

 ​ArrayIndexOutOfBoundsException异常（数组索引越界异常）

 public class Test6 {
     public static void main(String[ ] args) {
         int[ ] arr = new int[5];
         System.out.println(arr[5]);
     }
 }

 ​执行结果如图所示：

解决数组索引越界异常的方式，增加关于边界的判断： 

public class Test6 {
     public static void main(String[ ] args) {
         int[ ] arr = new int[5];
         int a = 5;
         if (a < arr.length) {
             System.out.println(arr[a]);
         }
     }
 }

 ​NumberFormatException异常（数字格式化异常）

public class Test7 {
     public static void main(String[ ] args) {
         String str = "1234abcf";
         System.out.println(Integer.parseInt(str));
     }
 }

执行结果如图所示：

数字格式化异常的解决，可以引入正则表达式判断是否为数字：

 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 ​
 ​
 public class Test7 {
     public static void main(String[ ] args) {
         String str = "1234abcf";
         Pattern p = Pattern.compile("^\\d+$");
         Matcher m = p.matcher(str);
         if (m.matches()) { // 如果str匹配代表数字的正则表达式,才会转换
             System.out.println(Integer.parseInt(str));
         }
     }
 }

2.CheckedException已检查异常

 异常在编译时就必须处理，否则无法通过编译。  

CheckedException异常的处理方式有两种：

1. 使用try/catch捕获异常

2. 使用throws声明异常。

异常的处理方式之一：捕获异常

try：

try语句指定了一段代码，该段代码就是异常捕获并处理的范围。在执行过程中，当任意一条语句产生异常时，就会跳过该条语句中后面的代码。代码中可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句要分别对这些异常做相应的处理。

一个try语句必须带有至少一个catch语句块或一个finally语句块。

注意事项

• 当异常处理的代码执行结束以后，不会回到try语句去执行尚未执行的代码。

catch：

1. 每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。

2. catch捕获异常时的捕获顺序：

   如果异常类之间有继承关系，先捕获子类异常再捕获父类异常。

finally：

1. 不管是否发生了异常，都必须要执行。

2. 通常在finally中关闭已打开的资源，比如：关闭文件流、释放数据库连接等。

try-catch-finally语句块的执行过程详细分析：

1. 程序首先执行可能发生异常的try语句块。

2. 如果try语句没有出现异常则执行完后跳至finally语句块执行；

3. 如果try语句出现异常，则中断执行并根据发生的异常类型跳至相应的catch语句块执行处理。

4. catch语句块可以有多个，分别捕获不同类型的异常。

5. catch语句块执行完后程序会继续执行finally语句块。

6. finally语句是可选的，如果有的话，则不管是否发生异常，finally语句都会被执行。

【示例】异常处理的典型代码(捕获异常)

 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 public class Test8 {
     public static void main(String[ ] args) {
         FileReader reader = null;
         try {
             reader = new FileReader("d:/a.txt");
             char c = (char) reader.read();
             char c2 = (char) reader.read();
             System.out.println("" + c + c2);
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 if (reader != null) {
                     reader.close();
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }
 }

常用开发环境中，自动增加try-catch代码块的快捷键：

1. 将需要处理异常的代码选中。

2. IDEA中，使用：ctrl+alt+t

3. eclipse中，使用：ctrl+shift+z

异常的处理方式之二：声明异常（throws子句）

1. CheckedException产生时，不一定立刻处理它，可以把异常throws，由调用者处理。
2. 一个方法抛出多个已检查异常，就必须在方法的首部列出所有的异常。

【示例】异常处理的典型代码（声明异常抛出throws）

   

    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    
    
    public class Test9 {
      public static void main(String[ ] args) {
        try {
          readFile("joke.txt");
         } catch (FileNotFoundException e) {
          System.out.println("所需文件不存在！");
         } catch (IOException e) {
          System.out.println("文件读写错误！");
         }
       }
      public static void readFile(String fileName) throws FileNotFoundException,
          IOException {
        FileReader in = new FileReader(fileName);
        int tem = 0;
        try {
          tem = in.read();
          while (tem != -1) {
            System.out.print((char) tem);
            tem = in.read();
           }
         } finally {
          if(in!=null) {
            in.close();
           }
         }
       }
    }
    

注意事项

🟤方法重写中声明异常原则：子类重写父类方法时，如果父类方法有声明异常，那么子类声明的异常范围不能超过父类声明的范围。

JDK新特性_

try-with-resource自动关闭AutoClosable接口的资源

JAVA中，JVM的垃圾回收机制可以对内部资源实现自动回收，给开发者带来了极大的便利。

但是JVM对外部资源(调用了底层操作系统的资源)的引用却无法自动回收，例如数据库连接，网络连接以及输入输出IO流等。这些连接就需要我们手动去关闭，不然会导致外部资源泄露，连接池溢出以及文件被异常占用等。

JDK7之后，新增了“try-with-resource”。它可以自动关闭实现了AutoClosable接口的类，实现类需要实现close()方法。

”try-with-resources “ 将try-catch-finally 简化为try-catch，这其实是一种语法糖，在编译时仍然会进行转化为try-catch-finally 语句。

  import java.io.FileReader;
    public class Test8 {
      public static void main(String[ ] args) {
        try(FileReader reader = new FileReader("d:/a.txt");) {
          char c = (char) reader.read();
          char c2 = (char) reader.read();
          System.out.println("" + c + c2);
         } catch (Exception e) {
          e.printStackTrace();
         }
       }
    }