Java学习_异常处理

1. 凡是可能抛出异常的语句，都可以用try ... catch捕获。把可能发生异常的语句放在try { ... }中，然后使用catch捕获对应的Exception及其子类。　　

2. 可以使用多个catch语句，每个catch分别捕获对应的Exception及其子类。JVM在捕获到异常后，会从上到下匹配catch语句，匹配到某个catch后，执行catch代码块，然后不再继续匹配。

   简单地说就是：多个catch语句只有一个能被执行。

3. 存在多个catch的时候，catch的顺序非常重要：子类必须写在前面。

4. 无论是否有异常发生，都希望执行一些语句，例如清理工作，可以把执行语句写若干遍：正常执行的放到try中，每个catch再写一遍。

    1 public static void main(String[] args) {
    2     try {
    3         process1();
    4         process2();
    5         process3();
    6         System.out.println("END");
    7     } catch (UnsupportedEncodingException e) {
    8         System.out.println("Bad encoding");
    9         System.out.println("END");
   10     } catch (IOException e) {
   11         System.out.println("IO error");
   12         System.out.println("END");
   13     }
   14 }

5. Java的try ... catch机制还提供了finally语句，finally语句块保证有无错误都会执行。上述代码可以改写如下。

   public static void main(String[] args) {
       try {
           process1();
           process2();
           process3();
       } catch (UnsupportedEncodingException e) {
           System.out.println("Bad encoding");
       } catch (IOException e) {
           System.out.println("IO error");
       } finally {
           System.out.println("END");
       }
   }

6. finally有几个特点：

   1. finally语句不是必须的，可写可不写；
   2. finally总是最后执行。
7. 某些情况下，可以没有catch，只使用try ... finally结构。

   void process(String file) throws IOException {
       try {
           ...
       } finally {
           System.out.println("END");
       }
   }

   因为方法声明了可能抛出的异常，所以可以不写catch。

1. 查看Integer.java源码可知，抛出异常的方法代码如下。

   public static int parseInt(String s, int radix) throws NumberFormatException {
       if (s == null) {
           throw new NumberFormatException("null");
       }
       ...
   }

2. 查看Integer.java源码可知，抛出异常的方法代码如下当发生错误时，例如，用户输入了非法的字符，我们就可以抛出异常。如何抛出异常？参考Integer.parseInt()方法，抛出异常分两步：

   1. 创建某个Exception的实例；
   2. 用throw语句抛出。

      void process2(String s) {
          if (s==null) {
              NullPointerException e = new NullPointerException();
              throw e;
          }
      }
      
      或：
      
      void process2(String s) {
          if (s==null) {
              throw new NullPointerException();
          }
      }

   3. 在代码中获取原始异常可以使用Throwable.getCause()方法。如果返回null，说明已经是“根异常”了。
   4. 捕获到异常并再次抛出时，一定要留住原始异常，否则很难定位第一案发现场！
3. 在try或者catch语句块中抛出异常，不会影响finally的执行。JVM会先执行finally，然后抛出异常。
4. 如果在执行finally语句时抛出异常，那么，finally抛出异常后，原来在catch中准备抛出的异常就“消失”了，因为只能抛出一个异常。没有被抛出的异常称为“被屏蔽”的异常（Suppressed Exception）。

   public class Main {
       public static void main(String[] args) {
           try {
               Integer.parseInt("abc");
           } catch (Exception e) {
               System.out.println("catched");
               throw new RuntimeException(e);
           } finally {
               System.out.println("finally");
               throw new IllegalArgumentException();
           }
       }
   }
   
   输出：
   
   catched
   finally
   Exception in thread "main" java.lang.IllegalArgumentException
   at Main.main(Main.java:11)

5. 在极少数的情况下，我们需要获知所有的异常。如何保存所有的异常信息？方法是先用origin变量保存原始异常，然后调用Throwable.addSuppressed()，把原始异常添加进来，最后在finally抛出。（通过Throwable.getSuppressed()可以获取所有的Suppressed Exception。绝大多数情况下，在finally中不要抛出异常。因此，通常不需要关心Suppressed Exception。）
   

    1 public class Main {
    2     public static void main(String[] args) throws Exception {
    3         Exception origin = null;
    4         try {
    5             System.out.println(Integer.parseInt("abc"));
    6         } catch (Exception e) {
    7             origin = e;
    8             throw e;
    9         } finally {
   10             Exception e = new IllegalArgumentException();
   11             if (origin != null) {
   12                 e.addSuppressed(origin);
   13             }
   14             throw e;
   15         }
   16     }
   17 }

NullPointerException

• NullPointerException即空指针异常，俗称NPE。如果一个对象为null，调用其方法或访问其字段就会产生NullPointerException，这个异常通常是由JVM抛出的。
• 指针这个概念实际上源自C语言，Java语言中并无指针。我们定义的变量实际上是引用，Null Pointer更确切地说是Null Reference。
• NullPointerException是一种代码逻辑错误，遇到NullPointerException，遵循原则是早暴露，早修复，严禁使用catch来隐藏这种编码错误。　　
• 成员变量在定义时初始化使用空字符串""而不是默认的null可避免很多NullPointerException，编写业务逻辑时，用空字符串""表示未填写比null安全得多。
• 如果调用方一定要根据null判断，比如返回null表示文件不存在，那么考虑返回Optional<T>

  public Optional<String> readFromFile(String file) {
      if (!fileExist(file)) {
          return Optional.empty();
      }
      ...
  }

  这样调用方必须通过Optional.isPresent()判断是否有结果。

• 定位NullPointerException

  • 　　从Java 14开始，如果产生了NullPointerException，JVM可以给出详细的信息告诉我们null对象到底是谁。

  • 这种增强的NullPointerException详细信息是Java 14新增的功能，但默认是关闭的，我们可以给JVM添加一个-XX:+ShowCodeDetailsInExceptionMessages参数启用它：

    java -XX:+ShowCodeDetailsInExceptionMessages Main.java

使用断言

• 断言（Assertion）是一种调试程序的方式。在Java中，使用assert关键字来实现断言。　

  public static void main(String[] args) {
      double x = Math.abs(-123.45);
      assert x >= 0;
      System.out.println(x);
  }

  语句assert x >= 0;即为断言，断言条件x >= 0预期为true。如果计算结果为false，则断言失败，抛出AssertionError。

• 使用assert语句时，还可以添加一个可选的断言消息。　

  assert x >= 0 : "x must >= 0";

  断言失败的时候，AssertionError会带上消息x must >= 0，更加便于调试。

使用JDK Logging

• Java标准库内置了日志包java.util.logging，可以直接用。

  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  public class Hello {
      public static void main(String[] args) {
          Logger logger = Logger.getGlobal();
          logger.info("start process...");
          logger.warning("memory is running out...");
          logger.fine("ignored.");
          logger.severe("process will be terminated...");
      }
  }

• 日志的输出可以设定级别。JDK的Logging定义了7个日志级别，从严重到普通：

  • SEVERE
  • WARNING
  • INFO
  • CONFIG
  • FINE
  • FINER
  • FINEST

Commons Logging(理解）

• Commons Logging是一个第三方日志库，它是由Apache创建的日志模块。Commons Logging的特色是，它可以挂接不同的日志系统，并通过配置文件指定挂接的日志系统。默认情况下，Commons Loggin自动搜索并使用Log4j（Log4j是另一个流行的日志系统），如果没有找到Log4j，再使用JDK Logging。

• 使用Commons Logging只需要和两个类打交道，并且只有两步：第一步，通过LogFactory获取Log类的实例； 第二步，使用Log实例的方法打日志。

  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  public class Main {
      public static void main(String[] args) {
          Log log = LogFactory.getLog(Main.class);
          log.info("start...");
          log.warn("end.");
      }
  }

使用Log4j

使用SLF4J和Logback