JAVA异常与捕获

异常存在即合理

为了保证程序在出现异常之后执行完毕，就需要进行异常处理
异常的类继承结构如下：

异常处理的格式：
try{
有可能出现异常的语句;
}[catch(异常类 对象){
}……]
[finally{
异常的出口;
}]
Throwable常用方法：

接下来通过两个例子好好感受一下异常处理：
例1：使用try…catch…finally进行处理

     //在进行异常处理时还可以使用try…catch…finally
    public class Test {
        public static void main(String[] args) {
            System.out.println("1:数学计算开始前");
            try{
                System.out.println("2:进行数学计算：" + 10/0);
            }catch(ArithmeticException e){
                e.printStackTrace();
                System.out.println("异常已被处理");
                System.out.println("捕获到的异常信息为：" + e.getMessage());
            }finally{
                System.out.println("不管是否产生异常，此语句都要执行");
            }
            System.out.println("3:数学计算结束后");
        }
    }
    //不管程序是否产生异常，最终都要执行finally程序代码，所以finally会作为程序的统一出口

输出结果：
java.lang.ArithmeticException: / by zero
1:数学计算开始前
java.lang.ArithmeticException: / by zero
异常已被处理
at 继承.Test.main(Test.java:49)
捕获到的异常信息为：/ by zero
不管是否产生异常，此语句都要执行
3:数学计算结束后：
例2：初始化参数进行数学运算

    public class Test{
        public static void main(String[] args) {
            System.out.println("1:数学计算开始前");
            try{
                int x = Integer.parseInt(args[0]);
                int y = Integer.parseInt(args[1]);
                System.out.println("2：进行数学计算" + x/y);
            }catch(ArithmeticException e){
                e.printStackTrace();
            }finally {
                System.out.println("不管是否产生异常，此语句都要执行");
            }
            System.out.println("3:数学计算结束");
        }
    }

输出结果：
1:数学计算开始前
不管是否产生异常，此语句都要执行
3:数学计算结束
java.lang.ArithmeticException: / by zero
at 继承.Test.main(Test.java:76)

以上两个例子中会出现如下问题：
被除数为0：ArithmeticException
看看下面的代码，预估一下输出结果是什么？

     public class Test {
        public static void main(String[] args) {
            try{
                System.out.println("try");
                return;
            }catch(Exception e){
                System.out.println("catch");
            }finally{
                System.out.println("finally");
            }
        }
     }

try
finally
结果分析：要想捕获异常（执行catch所包含的程序代码块），是不是得先有异常啊！

throws关键字
在进行方法定义的时候，如果要高书调用者本方法可能产生哪些异常，就可以使用throws方法进行声明。也就是该方法出现问题后不希望进行处理，就使用throws抛出。主方法和普通方法都可以使用throws进行定义。
例如1：throws定义普通方法

    public class Test{
        public static void main(String[] args) {
            try{
                System.out.println(calculate(1,0));
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        public static int calculate(int x,int y) throws Exception{
            return x/y;
        }
    }
    
    //java.lang.ArithmeticException: / by zero
    //        at 继承.Test.calculate(Test.java:103)
    //        at 继承.Test.main(Test.java:97)

分析：使用throws定义方法就是为了方法内部的异常可以忽略不处理，但是调用throws声明的方法，在调用时必须明确使用try…catch进行捕获，因为该方法可能产生异常，所以必须按照异常的方式来进行处理。
例2：throws定义主方法

    public class Test{
        public static void main(String[] args)throws Exception {
                System.out.println(calculate(1,0));
        }
        public static int calculate(int x,int y) throws Exception{
            return x/y;
        }
    }
    
    //    Exception in thread "main" java.lang.ArithmeticException: / by zero
    //        at 继承.Test.calculate(Test.java:99)
    //        at 继承.Test.main(Test.java:96)    

在主方法中使用throws进行异常抛出，如果产生了异常就会交给JVM处理
throw关键字
throw是直接编写在语句之中，表示人为进行异常的抛出。如果现在异常类对象实例化不希望由JVM产生而由用户产生，就可以使用throw来完成。

    public class Test{
        public static void main(String[] args)throws Exception {
               try{
                   throw new Exception("抛个异常出来看看");//产生的是一个对象
               }catch (Exception e){
                   e.printStackTrace();
               }
        }
    }
    
    //java.lang.Exception: 抛个异常出来看看
    //        at 继承.Test.main(Test.java:97)

throw + 异常类的实例化匿名对象
看到这里，能不能说出throw与throws的区别在哪里啊？

• throw用于方法内部，手工异常抛出

• throws用于方法声明上，明确告诉用户该方法可能产生异常，该方法不希望处理可能产生的异常
  RuntimeException运行时异常（非受查异常）
  在异常设计的时候，考虑到一些异常可能是简单问题，将这类异常称为RuntimeException，也就是说使用RuntimeException定义的异常可以不需要强制性进行异常处理
  那么，Exception与RuntimeException的区别在哪里呢？

• Exception是RuntimeException的父类，使用Exception定义的异常要求用户必须处理异常，而使用RuntimeException定义的异常，不做强制要求，可以选择性的进行异常处理

• 常见的RuntimeException包括ClassCastException和NullPointerException