异常处理升级版

其实前面就写了一篇异常处理的文章，但是那个文章实在是感觉太详细了，不太好复习。所以今天我就再写一篇这样就更好复习了。

一、异常概述

　　在我们日常生活中,有时会出现各种各样的异常,例如:职工小王开车去上班,在正常情况下,小王会准时到达单位。但是天有不测风云,在小王去上班时,可能会遇到一些异常情况,比如小王的车子出了故障,小王只能改为步行.

   　　 异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。

   　　 异常发生在程序运行期间,它影响了正常的程序执行流程

   　　 Java通过API中Throwable类的众多子类描述了各种不同的异常。Java中的异常都是对象,都是Throwable子类的实例。

   　　 每种异常类型都代表了一个错误的情况。
      　　  例如:
      　　  java.lang.ArrayIndexoutofBoundsException类,表示数组的下标在使用中超过了边界
      　　 java.lang.ClassCastException类,表示类型转换出现了错误

　　　　

二、Error和Exception概述

　　在Java中,所有的异常都有一个共同的父类Throwable,该类有两个重要的子类:Exception和Error,二者都是Java异常处理的重要子类,各自都包含大量子类。
   　　 它们都是java.lang下的类
  　　  java.lang.Throwable
  　　  java.lang.Error
  　　  java.lang.Exception

　　2.1、Error

　　　　这个是程序中发生的错误,是程序无法处理的,表示运行应用程序中较严重问题。而且很多错误与代码编写者执行的操作无关,而是表示代码运行时JVM出现了问题。

　　　　例如,Java虚拟机运行错误(VirtualMachineError),当JVM中内存不足时,将出现 OutOfMemoryError。这些error发生时,JVM一般会选择线程终止。
  　　　　 这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应时
    　　如Java虚拟机运行错误(VirtualMachineError)、类定义错误(NoClassDefFoundError)等。这些错误一般是不可查询的,因为它们在应用程序的控制和处理能力之外。

　　　　对于设计合理的应用程序来说,即使确实发生了错误,本质上也不应该试图去处理它所引起的异常状况,因为这是超出程序处理能力的。

　　2.2、Exception

　　这个是程序中发生的异常,是程序本身可以处理的,并且处理完之后程序本身还可以继续往下执行。
        我们进行抛出或捕获的异常就是这个Exception类型及其子类型。

三、异常的抛出与捕获

　　3.1、异常的抛出

　　　　在类中编写方法的时候,这个方法中将来被执行的代码如果有可能出现异常情况,那么就"可以"在方法的参数列表后声明该方法中可能会抛出的异常类型.

　　　　

public class Test{
            public void run()throws IOException,SQLException{
                //..
            }
        }

　　　　注意：

　　　　　　　　 1)如果有多个异常类型要抛出,那么需要使用逗号隔开.
      　　　　　　  2)所声明抛出的异常是该方法执行后"可能"会出现异常类型
       　　　　　　 3)异常抛给了方法的调用者,谁调用的这个方法谁就负责处理这些异常　　　　

　　3.2、异常捕获

　　　　当我们调用了一个方法,该方法在声明的时候抛出了异常,那么我们作为方法的调用者就必须去处理这些被抛出的异常。

　　　　例如：

　　　　　　Class类中的forName方法的声明

  public static Class<?> forName(String className)throws ClassNotFoundException

 
      　　  说明该方法在执行的时候有可能抛出ClassNotFoundException类型的异常,表示要加载的类找不到。
      　　  我们调用这个方法的时候,就需要对这个抛出的异常进行处理。

　　　　    第一种方式：继续把这个异常抛出去　

public static void main(String[] args)throws ClassNotFoundException{
                Class.forName("test....");
            }

　　　　　　在main方法中调用forName方法时候,我们并没有直接处理这个抛出的异常,而是继续把该异常往上抛出,抛给main方法的调用者。　　　　

　　　　　第二种方式：使用try-catch语句块把抛出的异常进行捕获

public static void main(String[] args) {
                try {
                    Class.forName("test...");
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }

　　分析：

　　　　　　1)try-catch是尝试着去捕获这些代码抛的异常,如果try语句块中的代码没有抛出异常,那么try-catch是没有任何作用的
            　　  2)如果try语句块中的代码抛出了异常,并且抛出的异常还是catch语句要处理的异常或其子类型异常,那么这时就会执行catch语句块中的代码,进行异常出现后的处理。
          　　    3)异常对象e常用的方法
              　　　　  e.printStackTrace()
                 　　　　   引用出堆栈中出现的异常跟踪信息
               　　　　 e.getMessage()
                  　　　　  返回异常的详细字符串信息(如果有的话)
           　　   4)不管方法声明中抛出了什么类型的异常,我们一般都是可以再catch中使用Exception类型进行捕获到的,因为Exception是所有异常的父类型。

　　　　　　　　例如：

try {
                    Class.forName("test...");
                    ....
                    ..
                } catch (Exception e) {
                    e.printStackTrace();
                }

　　　　    5)如果代码中抛出了多种异常,也可以使用多个catch来分别捕获.当然也可以只使用一个最大的异常Exception

try {
                    Class c = Class.forName("test..");
                    c.getMethod("go");
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (SecurityException e) {
                    e.printStackTrace();
                }

 　　3.3、throw和throws的区别

　　　　throw关键字是用于方法体内部，用来抛出一个Throwable类型的异常。如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。

　　　　该方法的调用者也必须检查处理抛出的异常。如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息

    public static void test() throws Exception  
    {  
       throw new Exception("方法test中的Exception");  
    }  

　　　　throws关键字用于方法体外部的方法声明部分，用来声明方法可能会抛出某些异常。仅当抛出了检查异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出.

四、抛出和捕获对程序的影响

　　4.1、如果程序中的某行代码的执行抛出了异常,并且这个异常一种都没有被try-catch处理,那么这个异常最终会抛给JVM,JVM输出异常信息后就自动停止了

public static void main(String[] args) throws ClassNotFoundException {
            System.out.println("hello");
            Class.forName("test..");
            System.out.println("world");
            //....其他代码
        }

　　　最终的结果是代码在调用forName方法抛出异常后,JVM处理后就停止了.并没有往下继续执行代码

　　4.2、如果使用try-catch语句去处理代码中抛出的异常,那么catch语句块处理完之后,代码还会在catch语句块下面继续执行

public static void main(String[] args){
            System.out.println("hello");
            try {
                Class.forName("test..");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            System.out.println("world");
            //....其他代码
        }

　　　　最终的结果是catch语句执行完后,代码继续往下正常执行。

　　4.3、try-catch语句块虽然能处理完异常后继续让代码往下执行,但是在某些时候也会改变代码的执行流程(默认是从上往下顺序执行)

public static void main(String[] args){
            System.out.println("hello");
            try {
                Class.forName("test..");
                System.out.println("world");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            //....其他代码
        }

　　　　最终的结果是catch语句执行完后,代码执行下面的其他代码,但是上面打印world的语句就跳过去了。

五、finally语句块

　　由于异常处理有时候会改变程序的正常流程，这会使得某些不管在任何情况下都必须执行的步骤被忽略，从而影响程序的健壮性。
　　举例：

　　　　小王开了一家店，在店里上班的正常流程为:打开店门、工作8个小时、关门。异常流程为：小王在工作时突然犯病，因而提前下班

public void work() {
            try {
                开门();
                工作8个小时();
                关门();
            } catch(Exception e) {
                去医院();
            } 
        }

　　　　小王在工作时突然犯病，那么流程会跳转到catch代码块，这意味着关门的操作不会被执行，这样的流程显然是不安全的，必须确保关门的操作在任何情况下都会被执行.

　　　　finally代码块能保证特定的操作总是会被执行，它的形式如下：

public void work() {
            try {
                开门();
                工作8个小时();
            } catch(Exception e) {
                去医院()
            } finally {
                关门();
            }
        }

　　　　　注:即使方法中执行了return语句,finally最后也是会被执行的。

　　try、catch、finally三个语句块应注意的问题

　　　　1）try、catch、finally三个语句块均不能单独使用，三者可以组成 try...catch...finally、try...catch、try...finally三种结构，catch语句可以有一个或多个，finally语句最多一个。
  　　     2）try、catch、finally三个代码块中变量的作用域为代码块内部，分别独立而不能相互访问。如果要在三个块中都可以访问，则需要将变量定义到这些块的外面。
   　　　3）多个catch块时候，最多只会匹配其中一个异常类且只会执行该catch块代码，而不会再执行其它的catch块，且匹配catch语句的顺序为从上到下，也可能所有的catch都没执行。
             4）先Catch子类异常再Catch父类异常。

　　　　图解：

　　　　　　                                             

六、编译时异常和运行时异常

　    　1)Exception有一个特殊的子类:RuntimeException
   　　 2)RuntimeException类型及其子类型都是属于运行时异常
   　　 3)其他类型的异常只要不是继承了RuntimeException类的,都属于编译异常
   　　 4)编译异常又称checked异常,运行时异常又称unchecked异常
        　　因为编译器在编译期间如果遇到了checked异常,那么是一定会提示我们,让我们去处理的。但是如果遇到了unchecked异常,编译器是不做任何事情的。

　　6.1、常见的运行时异常：unchecked

　　　　 java.lang.ArithmeticException  
           　　 算术异常
       　　 java.lang.NullPointerException  
           　　 空指针引用
       　　 java.lang.ArrayIndexoutofBoundsException  
          　　  数组越界
       　　 java.lang.ClassCastException
           　　 强制类型转换异常
       　　 java.lang.NumberFormatException  
           　　 数据格式异常
       　　 java.lang.NegativeArraySizeException
       　　　　 数组长度为负数异常

　　6.2、常见的运行时异常:checked

　　　　编译器提示你需要处理的都为编译异常
       　　 java.lang.ClassNotFoundException
      　　  java.lang.DataFormatException
     　　   java.lang.NoSuchMethodException
     　　   java.io.IOException
      　　  java.sql.SQLException

七、自定义异常

　　在需要的情况下,可以通过扩展Exception类或RuntimeException类来创建自定义的异常(一般是扩展Exception类)。异常类包含了和异常相关的信息,这有助于负责捕获异常的catch代码块，正确地分析并处理异常。　　　　　

　　

　　例如:我们任务在系统中用户要登录的账号和密码不匹配就是一种异常情况,但是JDK中并没有定义这种异常,所以我们可以进行自定义。
      例如: 只需继承Exception即可.一般还会加入和父类中匹配的构造器

public class UserPasswordException extends Exception{

        public UserPasswordException() {
            super();
        }

        public UserPasswordException(String message, Throwable cause, boolean enableSuppression,
                boolean writableStackTrace) {
            super(message, cause, enableSuppression, writableStackTrace);
        }

        public UserPasswordException(String message, Throwable cause) {
            super(message, cause);
        }

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

        public UserPasswordException(Throwable cause) {
            super(cause);
        }
        
    }

　　　注:异常是可以在代码中主动抛出的

public void login(String password)throws UserPasswordException{
            
            if("123".equals(password)){
                throw new UserPasswordException("密码错误");
            }

        }

　　UserPasswordException

八、断言

　　8.1、断言使用  

     在JDK1.4中，Java语言引入一个新的关键字： assert  该关键字有两种形式：
        assert  条件

        以及

        assert  条件:值或表达式

        这两种形式都会对条件进行评估，如果结果为false则抛出AssertionError。
        在第二种形式中，值或表达式的值会传入AssertionError的
        构造器并转成一个消息字符串,成为要显示的错误信息

        例如:
        要断言x不是负数，只需要使用如下简单的语句：
        assert x >= 0;

        或者你可以将x的值传递给AssertionError对象，从而可以在报错时候显示：

        assert x >= 0 : x;
        
        或者
        assert x >= 0 : "x的值不符合条件:x="+x;

　　8.2、断言内容代码编译

        因为assert在JDK1.4中是一个新的关键字，因此在使用时需要告诉编译器你编译所使用jdk的版本号。

        javac -source 1.4 MyClass.java

        在jdk的后续版本中，对断言的支持成为默认特性(JDK5.0以上使用时就不需要这个编译了,因为默认就支持的)。

　　8.3、断言内容代码编译

        因为assert在JDK1.4中是一个新的关键字，因此在使用时需要告诉编译器你编译所使用jdk的版本号。

        javac -source 1.4 MyClass.java

        在jdk的后续版本中，对断言的支持成为默认特性(JDK5.0以上使用时就不需要这个编译了,因为默认就支持的)。

　　　　　注意:使用eclipse运行代码的时候也是可以传参数的(包括俩种参数)
    
    　　　　例如:
   　　　　　　 java -xx com.briup.ch07.Test yy
   　　　　　　 xx是给JVM传的参数  yy是给Test类的main方法传的参数