【原】Java学习笔记030 - 异常

 package cn.temptation;

 public class Sample01 {
     public static void main(String[] args) {
         /*
          * 异常：Java程序在运行过程中出现的错误
          *
          * 类 Throwable：Java 语言中所有错误或异常的超类。
          * 只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。
          * 类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。
          *
          * 类 Error：Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。
          * 大多数这样的错误都是异常条件。虽然 ThreadDeath 错误是一个“正规”的条件，但它也是 Error 的子类，因为大多数应用程序都不应该试图捕获它。
          *
          * 类 Exception：Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。
          *
          * 异常的分类：
          * 1、编译时异常：Exception类中除去RuntimeException及其子类以外其他的
          * 2、运行时异常：RuntimeException及其子类
          *
          * 异常的处理方式：
          * 1、try...catch...finally格式及其变体
          * 2、throws/throw
          *
          * try...catch...finally处理方式：
          * try {
          *         可能出现问题的代码
          * } catch(异常名称   变量) {
          *         针对问题的处理
          * } finally {
          *         释放资源等操作
          * }
          *
          * try...catch...finally处理的变体方式：
          * try {
          *         可能出现问题的代码
          * } catch(异常名称   变量) {
          *         针对问题的处理
          * }
          */

         // 下句语句编译阶段无语法错误，但是执行时产生异常，这个异常不是由开发人员来处理，应该由开发人员编写代码时就进行判断处理
 //        System.out.println(2 / 0);

         // 【针对单个异常】
 //        try {
 //            System.out.println(2 / 0);
 //        } catch (ArithmeticException e) {
 //            System.out.println("除数不能为0");
 //        }

         // 【针对多个异常】
         int[] arr = { 1, 2, 3 };

 //        try {
 //            // 如果没有进行异常处理，执行时，首先JVM捕获数组越界异常
 //            System.out.println(arr[3]);
 //            System.out.println(2 / 0);
 //        } catch (ArrayIndexOutOfBoundsException e) {
 //            System.out.println("数组的索引越界");
 //        } catch (ArithmeticException e) {
 //            System.out.println("除数不能为0");
 //        }

         // 上述的异常处理代码会显示"数组的索引越界"，因为代码的顺序执行，首先捕获到索引越界异常，如果解决掉这个问题，再执行会捕获到除数为0的异常

 //        try {
 //            System.out.println(arr[3]);
 //            System.out.println(2 / 0);
 //        } catch (Exception e) {
 //            System.out.println("代码有问题");
 //        }

         // 上述的异常处理代码使用异常基类Exception类，这样不用明确指出是哪一种异常（偷懒写法）

         // 【JDK 1.7之后开始支持的语法】
         try {
             System.out.println(arr[3]);
             System.out.println(2 / 0);
         } catch (ArrayIndexOutOfBoundsException | ArithmeticException e) {
             System.out.println("代码有问题");
         }

         // 上述的异常处理代码需要多个异常是针对同一类类型的问题，否则无法明确具体是什么异常
     }
 }

 package cn.temptation;

 public class Sample02 {
     public static void main(String[] args) {
         /*
          * 对异常的两种处理方式的理解：
          * 类比生病
          * 1、哪里有病了哪里疼痛，直接就在对应的问题就发现问题
          * 2、有病的地方并不是病因产生的地方，而是病状呈现的地方，也就是问题不断抛出最后得到的结果
          */

         // try...catch...finally处理时的注意问题：
         // 1、同时使用父类异常 和  子类异常时，父类异常不能写在子类异常之前，否则有语法错误
 //        try {
 //            System.out.println(2 / 0);
 //        } catch (Exception e) {
 //            System.out.println("代码有问题");
 //        } catch (ArithmeticException e) {
 //            // 语法错误：Unreachable catch block for ArithmeticException. It is already handled by the catch block for Exception
 //            System.out.println("除数不能为0");
 //        }

         // 下面语句执行时显示子类异常信息
         try {
             System.out.println(2 / 0);
         } catch (ArithmeticException e) {
             // 语法错误：Unreachable catch block for ArithmeticException. It is already handled by the catch block for Exception
             System.out.println("除数不能为0");
         } catch (Exception e) {
             System.out.println("代码有问题");
         }
     }
 }

 package cn.temptation;

 public class Sample03 {
     public static void main(String[] args) {
         /*
          * Throwable类的常用成员方法：
          * 1、String getMessage() ：返回此 throwable 的详细消息字符串。
          * 2、String toString() ：返回此 throwable 的简短描述。
          * 3、void printStackTrace() ：将此 throwable 及其追踪输出至标准错误流。
          */

         try {
             System.out.println(2 / 0);
         } catch (Exception e) {
             System.out.println(e.getMessage());        // / by zero
             System.out.println(e.toString());        // java.lang.ArithmeticException: / by zero
             e.printStackTrace();                    // java.lang.ArithmeticException: / by zero at cn.temptation.Sample03.main(Sample03.java:13)
         }
     }
 }

 package cn.temptation;

 public class Sample04 {
     public static void main(String[] args) {
         /*
          * throws 关键字的使用：
          * 定义方法时，使用throws关键字标记需要暴露出来被开发人员处理的问题
          */

         // 下句语句对calc方法的调用，因为在主函数中没有对calc方法抛出的异常进行处理，所以异常还是由jvm进行捕获
         // 调用calc方法，收到其抛出的异常，没有进行处理
 //        calc();

         try {
             // 调用calc方法，收到其抛出的异常，并进行处理
             calc();
         } catch (ArithmeticException e) {
             System.out.println("除数不为0");
         }
     }

     // 在方法内部对异常不进行处理，在方法的声明上通过throws标记需要处理的异常，并向外抛出
     // 定义计算方法
     public static void calc() throws ArithmeticException {
         System.out.println(2 / 0);
     }
 }

 package cn.temptation;

 public class Sample05 {
     public static void main(String[] args) {
         /*
          * throw关键字的使用：
          * 用在方法内部，出现某种情况程序无法继续运行时，需要进行跳转通过throw把异常对象进行抛出
          *
          *
          * throws 和 throw 的区别：
          * 1、throws
          * A：用在方法声明中，后面是异常类名
          * B：throws后可以有多个异常类名，之间使用英文逗号分隔
          * C：表示抛出异常，由方法的调用者进行处理
          * D：throws表示出现异常的可能，不一定会发生这些异常
          *
          * 2、throw
          * A：用在方法内，后面是异常类的对象
          * B：throw后只能抛出一个异常对象
          * C：表示抛出异常，由方法内的语句处理，方法被调用时，调用方法处进行捕获处理
          * D：throw表示抛出异常，执行throw一定是抛出了某种异常
          */

         // 使用throw关键字，在方法中抛出异常的实例对象，方法调用时没有语法错误
 //        calc();

         // 下面代码捕获到ArithmeticException异常，并执行catch代码块的处理
 //        try {
 //            calc();
 //        } catch (ArithmeticException e) {
 //            System.out.println("计算异常");
 //        }

         // 方法声明上throws出的异常 和 方法内throw出的异常是父子关系，必须进行异常处理，否则就语法出错
 //        method1();

 //        try {
 //            method1();
 //        } catch (Exception e) {
 //            System.out.println("除数不为0");
 //        }

         // 方法声明上throws出的异常 和 方法内throw出的异常同级且不相同，以throw出的异常为准
         method2();
     }

     // 声明计算方法
     public static void calc() {
         int i = 2;
         int j = 0;

         if (j == 0) {        // 判断除数是0
             throw new ArithmeticException();
         } else {
             System.out.println(i / j);
         }
     }

     public static void method1() throws Exception {
         int i = 2;
         int j = 0;

         if (j == 0) {        // 判断除数是0
             throw new ArithmeticException();
         } else {
             System.out.println(i / j);
         }
     }

     public static void method2() throws ArrayIndexOutOfBoundsException {
         int i = 2;
         int j = 0;

         if (j == 0) {        // 判断除数是0
             throw new ArithmeticException();
         } else {
             System.out.println(i / j);
         }
     }
 }

 package cn.temptation;

 public class Sample06 {
     public static void main(String[] args) {
         /*
          * 两种异常处理方式的选择：
          * 1、如果在方法内部进行处理，选择try...catch...finally结构
          * 2、如果在方法外部进行处理，选择throws/throw
          *
          * finally的特点：finally中的语句一定会被执行
          * 注意：在执行finally语句块之前虚拟机终止了，那么finally语句块中的语句不会执行
          */

         try {
             System.out.println(2 / 0);
         } catch (Exception e) {
             System.out.println("异常处理");
             /*
              * System类的常用成员方法：
              * static void exit(int status) ：终止当前正在运行的 Java 虚拟机。
              */
             System.exit(0);
         } finally {
             System.out.println("finally中的语句一定会被执行");
         }
     }
 }

 package cn.temptation;

 public class Sample07 {
     public static void main(String[] args) {
         // 在try...catch...finally...结构中使用return的问题：
         // 1、catch语句块中有return语句，finally语句块中没有return语句，执行顺序为：
         //        先执行catch语句块中return语句之前的语句，再执行finally语句块中的语句，最后执行catch中的return语句，显示结果为4
         // 2、catch语句块中有return语句，finally语句块中也有return语句，执行顺序为：
         //        先执行catch语句块中return语句之前的语句，再执行catch中的return语句，然后执行finally语句块中的语句，最后执行finally语句块中的return语句，显示结果为5
         System.out.println(show());
     }

     public static int show() {
         try {
             System.out.println(2 / 0);
             return 3;
         } catch (Exception e) {
             System.out.println("异常处理");
             return 4;
         } finally {
             System.out.println("finally中的语句");
             return 5;
         }
     }
 }

 package cn.temptation;

 public class Sample08 {
     public static void main(String[] args) {
         // try...catch...finally...形式
         // 完整形式
         try {

         } catch (Exception e) {

         } finally {

         }

         // try...catch..（单个异常）
         try {

         } catch (Exception e) {

         }

         // try...catch..（多个异常）
         try {

         } catch (ArithmeticException e) {

         } catch (Exception e) {

         }

         // try...finally...
         // 没有catch代码块结构语法也正确，这种形式目的是为了使用后释放资源
         try {

         } finally {

         }

         // 语法错误
 //        try {
 //
 //        }

         // 语法错误
 //        catch (Exception e) {
 //
 //        }

         // 语法错误
 //        catch (Exception e) {
 //
 //        } finally {
 //
 //        }

         // 语法错误
 //        finally {
 //
 //        }
     }
 }

 package cn.temptation;

 public class Sample09 {
     public static void main(String[] args) {
         // 自定义异常类
         try {
             show(200);
         } catch (TestException e) {
             e.printStackTrace();
         }
     }

     public static void show(int age) throws TestException {
         if (age < 0 || age > 150) {
             throw new TestException("年龄错误！");
         } else {
             System.out.println("年龄为：" + age);
         }
     }
 }

 /**
  * 自定义异常类
  */
 class TestException extends Exception {
     // 构造函数
     public TestException() {

     }

     public TestException(String msg) {
         super(msg);
     }
 }