Java异常与异常处理简单使用

　　异常就是程序运行过程中阻止当前方法或作用域继续执行的问题；

　　任何程序都不能保证完全正常运行，当发生异常时，需要我们去处理异常，特别是一些比较重要的场景，异常处理的逻辑也会比较复杂，比如：给用户提示、保存当前用户操作或改动、未完成的业务回滚、释放程序占用的资源等。

　　在Java中，Throwable异常类是所有异常类的祖先，任何异常类都继承于Throwable类；

　　Throwable类主要有两个子类：Error类、Exception类

　　Error异常类是系统异常，比如：虚拟机错误(VirtualMachineError)、线程死锁(ThreadDeath)等，Error类异常一旦发生，程序将会崩溃

　　Exception是开发中我们最常见的一般异常，这种异常原因可能是程序代码编写错误，环境问题，用户输入错误等异常

　　Exception异常一般分为：运行时异常(RuntimeException)也称为非检查异常、检查异常；

　　非检查异常常见的有：输出空指针时的异常，数组下标越界异常，类型转换异常，算术异常(比如0作为分母)等，运行时异常会由Java虚拟机自动捕获，自动抛出，一般是我们写的代码本身有问题，需要改进我们的代码来解决

　　检查异常的原因有可能是：文件异常(不存在或者权限)、数据库连接异常、网络连接异常等，这种异常系统不会自动捕获，需要我们手动添加捕获处理的语句

　　

　　我们通常使用try-catch以及try-catch-finally代码块来处理异常

　　try代码块中是可能发生异常的语句，当程序确实发生异常了，try块中程序会中止执行，并且抛出异常给catch块进行处理，catch根据需要去处理异常、记录错误日志等，看一个简单示例：

 import java.util.Scanner;

 public class Ceshi {
     public static void main(String[] args){
         try{
             System.out.println("请输入一个整数：");
             Scanner input = new Scanner(System.in);
             int a = input.nextInt();
             System.out.println("您输入的是：" + a);
         }catch(Exception e){
             System.out.println("输入异常");
             e.printStackTrace();    //打印异常信息
         }
         System.out.println("程序执行结束");
     }
 }

这是一个最简单的异常处理，通过Scanner获取用户输入，当用户正确输入时程序正常执行，当然catch块不会被执行，但是用户如果输入的不是整数，那么就会抛出异常给catch块，可以利用printStackTrace()方法打印具体的异常，注意无论程序是否异常try-catch外的语句都会被正常执行，错误结果如下：

根据结果可以看到我们输入字符串"3s"之后，抛出了异常并且提示输入异常，最后但是try-catch后面的语句正常执行，抛出的e.printStackTrace()会在最后被打印出来，可以看出来是Ceshi.java第就行发生了异常产生了终止，那么就是在a接收输入这一行语句中发生的异常，那么在这一行之后的所有try块中的语句便终止执行

另外如果try中的代码会抛出好几个类型的异常，那么我们需要多个catch块来处理，并且加上finally进行善后处理工作

 import java.util.Scanner;
 import java.util.InputMismatchException;
 import java.lang.ArithmeticException;
 public class Ceshi {
     public static void main(String[] args){
         Scanner input = new Scanner(System.in);
         try{
             System.out.println("请输入分子：");
             int a = input.nextInt();
             System.out.println("您输入分母：");
             int b = input.nextInt();
             System.out.println("计算结果是：" + a*1.0/b);
         }catch(InputMismatchException e){
             System.out.println("请输入整数");
             e.printStackTrace();    //打印异常信息
         }catch(ArithmeticException e){
             System.out.println("分母不能为0");
             e.printStackTrace();    //打印异常信息
         }catch(Exception e){
             System.out.println("其他未知异常");
             e.printStackTrace();
         }finally{
             input.close();
         }
         System.out.println("程序执行结束");
     }
 }

以上的处理就比较合理了，首先保证输入是整数，如果都是整数那么分母为0也会抛出异常，最后如果还有我们考虑不到的异常，那么就通过Exception父类抛出异常，catch异常块从上到下一般是是由小到大或者由子类到父类的异常类抛出，就是从作用范围来说从细节到整体，Exception异常类抛出必须放在最后面，这样能抛出我们开发中遇到的所有异常，另外finally块建议带上，当遇到异常时，他可以释放前面还未操作的系统资源，比如例子中的关闭输入，这样能提高程序的健壮性，如果try和catch中有返回值，那么finally中的语句会在try和catch语句块中的return返回值返回到调用者之前，获得该返回值，我们可以在程序中输出他们，但是放在try-catch-finally外返回值时在finally是无法获取到的，只能获取前面的变量值

　　Java中方法异常抛出，因为很多代码我们会写到方法中，为了便于管理，我们可以在专门的方法中处理异常，所以我们可以将方法中的异常向上抛出，可以写一个方法来简单抛出异常，代码如下：

 public void divide(int a,int b) throws Exception {
     if(b == 0){
         throw new Exception("除数不能为零！");
     }else{
         System.out.println("结果为：" + a*1.0/b);
     }
 }

当该方法被调用时，那么如果发生异常，异常将抛出到调用的语句块中，我们可以在调用的时候进行处理，比如：

 public void complte() {
     try{
         divide(5,0);    //此时发生异常，调用方法将异常抛出到这里
     }catch(Exception e){
         System.out.println(e.getMessage());    //此处捕获异常，将方法中定义的异常信息抛出
     }
 }

这样就把方法中的异常抛出并进行了处理，另外我们还可以不在complte方法中抛出，还可以向上抛出，由上面调用该方法时抛出异常，代码如下：

public void complte() throws Exception {
    /**
     * 省略方法中的代码
     */
    divide(5,0);    //将里面的异常抛出到调用complte方法的位置
}

这样的话异常继续向上抛出，最终还是按照第二段代码的方式来处理异常，所以用throws关键字声明此方法向上抛出异常，用throw关键字来抛出异常

　　自定义异常

　　除了利用系统的异常我们还可以自定义异常，以便适应我们情景的需要，简单定义个异常类：

 public class CeshiException extends Exception {

     public CeshiException(){

     }

     public CeshiException(String message){
         super(message);
     }
 }

注意，自定义异常类必须继承于Exception异常类，里面定义了一个有参数的构造方法来自定义异常信息，无参的构造方法是为了实例化类时，默认不会发生错误，那么我们可以在方法中具体来使用这个自定义异常类了：

 public class ChainTest {

     /**
      * test1():抛出自定义异常
      * test2():调用test1(),捕获自定义异常，并且包装成运行时异常，抛出新异常
      * main方法中，调用test2(),尝试捕获test2()方法抛出的异常
      */
     public static void main(String[] args) {
         ChainTest ct = new ChainTest();
         try{
             ct.test2();
         }catch(Exception e){
             e.printStackTrace();
         }
     }

     public void test1() throws CeshiException{
         throw new CeshiException("原始自定义异常抛出");
     }

     public void test2(){
         try {
             test1();
         } catch (CeshiException e) {
             // TODO Auto-generated catch block
             RuntimeException newExc =
                 new RuntimeException("抛出新运行时异常");
             newExc.initCause(e);    //引用原始异常方法，异常链
             throw newExc;
         }
     }
 }

根据代码可以看出，main方法调用test2方法并捕获test2方法抛出的异常，而test2方法中运行test1并捕获test1方法中抛出的自定义异常，并且自己也抛出一个新的运行时异常抛出到main方法中，而test1方法通过声明自定义异常类实现了抛出自定义异常类中的异常方法，将异常抛出到test2中，这样就好比一连串的异常抛出和异常处理，同时结合了自定义异常，这样就形成了一个小型的异常链，就好像链式反应一样去抛出异常

　　最后，总结一下，通过try-catch来处理异常，并不能避免错误的存在性，而是尽量提高程序的健壮性，减小程序错误而带来的安全风险和损失，我们不能一味的用try-catch来屏蔽错误，我们应该采用合理的逻辑算法来解决程序设计的不足，try-catch只是一个作为辅助使用，不可以过分依赖；

　　在多重catch块之后，最好加个catch(Exception e){}来处理其他可能会被遗漏的未知的异常，对于不太确定的异常，可以加上try-catch来处理潜在的风险；

　　对于异常一定要尽量去处理，千万不要只是简单地使用e.printStackTrace();来打印错误信息，这样就失去了异常处理的意义；

　　具体如何处理异常，应该根据不同的业务需求和异常类型来确定；

　　最后要善于在try-catch块后面添加finally语句块，释放系统资源的占用，比如网络连接、数据库连接、文件关闭等；

　　什么时候怎么使用异常，还需要自己以后在开发中慢慢的熟悉