java异常处理一

发表于 | 阅读量 次 | 分类于 |

前言

不得不说，我们平时在写程序时遇到最多的情形或者最头疼的事情就是遇到异常，然后各种调试，各种方法用尽最后才解决它，那么异常主要分为几类，每个类又有什么特征了（如图）
Alt text
从大的角度说主要分成两类：Error类代表了编译和系统的错误，不允许捕获，也就是我们自己无法主动去处理它；Exception类代表了我们可捕获并且可自己可处理异常，而Exception有包括两类，一个是你必须要处理的异常，如某个类有throws异常了，在未进入运行期就必须处理，另一类就是Runtime Exception（运行期异常），就是只有在运行时（也就是编译成class文件）时才知道，这个异常可处理或不处理

处理异常机制

在java应用程序中，异常处理机制主要为两种:抛出异常和捕获异常
抛出异常
简单的说，就是不处理异常，将异常不断抛给上一级，直至某一级有有处理异常措施，一般用throws、throw如

public readFile() throws IOException{
throw new xxx();
}

捕获异常
定义是这样说的，在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适 的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。
一般有try..catch语句块，其语法格式如下：

try {
// 可能会发生异常的程序代码
} catch (Type1 id1){
// 捕获并处置try抛出的异常类型Type1
}
catch (Type2 id2){
//捕获并处置try抛出的异常类型Type2
} 

如果，不管异常有没有捕获，都要执行某段代码，如数据库查询后都要关闭等等，就可以用finally，上面修改

try {
// 可能会发生异常的程序代码
} catch (Type1 id1){
// 捕获并处置try抛出的异常类型Type1
}
catch (Type2 id2){
//捕获并处置try抛出的异常类型Type2
} finally{
//必须执行的代码
}

try-catch-finally 规则

try块：用于捕获异常。其后可接0个或多个catch块，如果没有catch块，则必须跟一个finally块
catch块：用于处理try捕获到的异常。
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：

1）在finally语句块中发生了异常。
2）在前面的代码中用了System.exit()退出程序。
3）程序所在的线程死亡。
4）关闭CPU。

try..catch..拥有执行顺序，即第一个catch之后，后面不在执行catch，所以一般将较详细的catch放在最前面，如先捕获IOException在捕获Exception

throws规则

1) 如果是不可查异常（unchecked exception），即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。

2）必须声明方法可抛出的任何可查异常（checked exception）。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误

3)仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出

4）调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。
如下

void method1() throws IOException{}  //合法    

//编译错误，必须捕获或声明抛出IOException    
void method2(){    
  method1();    
}    

//合法，声明抛出IOException    
void method3()throws IOException {    
  method1();    
}    

//合法，声明抛出Exception，IOException是Exception的子类    
void method4()throws Exception {    
  method1();    
}    

//合法，捕获IOException    
void method5(){    
 try{    
    method1();    
 }catch(IOException e){…}    
}    

//编译错误，必须捕获或声明抛出Exception    
void method6(){    
  try{    
    method1();    
  }catch(IOException e){throw new Exception();}    
}    

//合法，声明抛出Exception    
void method7()throws Exception{    
 try{    
  method1();    
 }catch(IOException e){throw new Exception();}    
}   

这里需要注意的是throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象

Throwable类源码分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
/**  
    *   
    * Throwable是所有Error和Exceptiong的父类  
    * 注意它有四个构造函数:  
    * Throwable()  
    * Throwable(String message)  
    * Throwable(Throwable cause)  
    * Throwable(String message, Throwable cause)  
    *   
    */    
    public class Throwable implements Serializable {    
          private static final long serialVersionUID = -3042686055658047285L;    
        
          /**  
           * Native code saves some indication of the stack backtrace in this slot.  
           */    
          private transient Object backtrace;     
          /** 
       * 描述此异常的信息 
       */  
      private String detailMessage;  
  
      /** 
       * 表示当前异常由那个Throwable引起 
        * 如果为null表示此异常不是由其他Throwable引起的 
        * 如果此对象与自己相同,表明此异常的起因对象还没有被初始化 
       */  
      private Throwable cause = this;  
  
      /** 
       * 描述异常轨迹的数组 
       */  
      private StackTraceElement[] stackTrace;  
      /** 
       * 构造函数,起因对象没有被初始化可以在以后使用initCause进行初始化 
        * fillInStackTrace可以用来初始化它的异常轨迹的数组 
       */  
      public Throwable() {  
          fillInStackTrace();  
      }  
  
      /** 
       * 构造函数 
       */  
      public Throwable(String message) {  
         //填充异常轨迹数组  
          fillInStackTrace();  
         //初始化异常描述信息  
          detailMessage = message;  
      }  
  
      /** 
       * 构造函数,cause表示起因对象 
       */  
      public Throwable(String message, Throwable cause) {  
          fillInStackTrace();  
          detailMessage = message;  
          this.cause = cause;  
      }  
  
      /** 
       * 构造函数 
       */  
      public Throwable(Throwable cause) {  
          fillInStackTrace();  
          detailMessage = (cause==null ? null : cause.toString());  
          this.cause = cause;  
      }  
      /** 
       * 获取详细信息 
       */  
      public String getMessage() {  
          return detailMessage;  
      }  
      /** 
       * 获取详细信息 
       */  
      public String getLocalizedMessage() {  
          return getMessage();  
      }  
       /** 
       * 获取起因对象 
       */  
      public Throwable getCause() {  
          return (cause==this ? null : cause);  
      }  
      /** 
       * 初始化起因对象,这个方法只能在未被初始化的情况下调用一次 
       */  
      public synchronized Throwable initCause(Throwable cause) {  
         //如果不是未初始化状态则抛出异常  
          if (this.cause != this)  
              throw new IllegalStateException("Can't overwrite cause");  
          
         //要设置的起因对象与自身相等则抛出异常  
          if (cause == this)  
              throw new IllegalArgumentException("Self-causation not permitted");  
          
         //设置起因对象  
          this.cause = cause;  
         //返回设置的起因的对象  
          return this;  
      }  
      /** 
       * 字符串表示形式 
       */  
      public String toString() {       
          String s = getClass().getName();          
          String message = getLocalizedMessage();        
          return (message != null) ? (s + ": " + message) : s;  
      }  
      /** 
       * 打印出错误轨迹 
       */  
      public void printStackTrace() {   
          printStackTrace(System.err);  
      }  
       /** 
       * 打印出错误轨迹 
       */  
      public void printStackTrace(PrintStream s) {  
          synchronized (s) {  
            //调用当前对象的toString方法  
              s.println(this);  
            //获取异常轨迹数组  
              StackTraceElement[] trace = getOurStackTrace();  
              
            //打印出每个元素的字符串表示  
              for (int i=0; i < trace.length; i++)  
                s.println("\tat " + trace[i]);  
  
            //获取起因对象  
              Throwable ourCause = getCause();  
              
            //递归的打印出起因对象的信息  
              if (ourCause != null)  
                ourCause.printStackTraceAsCause(s, trace);  
          }  
      }  
       /** 
       * 打印起因对象的信息 
       * @param s 打印的流 
        * @param causedTrace 有此对象引起的异常的异常轨迹  
       */  
      private void printStackTraceAsCause(PrintStream s,  
                                          StackTraceElement[] causedTrace)  
      {  
         //获得当前的异常轨迹  
          StackTraceElement[] trace = getOurStackTrace();  
         //m为当前异常轨迹数组的最后一个元素位置,   
         //n为当前对象引起的异常的异常轨迹数组的最后一个元素  
          int m = trace.length-1, n = causedTrace.length-1;  
         //分别从两个数组的后面做循环,如果相等则一直循环,直到不等或数组到头  
          while (m >= 0 && n >=0 && trace[m].equals(causedTrace[n])) {  
              m--; n--;  
         }  
          
         //相同的个数  
          int framesInCommon = trace.length - 1 - m;  
          
         //打印出不同的错误轨迹  
          s.println("Caused by: " + this);  
          for (int i=0; i <= m; i++)  
              s.println("\tat " + trace[i]);  
          //如果有相同的则打印出相同的个数  
          if (framesInCommon != 0)  
              s.println("\t... " + framesInCommon + " more");  
  
         //获得此对象的起因对象,并递归打印出信息  
          Throwable ourCause = getCause();  
          if (ourCause != null)  
              ourCause.printStackTraceAsCause(s, trace);  
      }  
  
      /** 
       * 打印出错误轨迹 
       */  
      public void printStackTrace(PrintWriter s) {   
          synchronized (s) {  
              s.println(this);  
              StackTraceElement[] trace = getOurStackTrace();  
              for (int i=0; i < trace.length; i++)  
                  s.println("\tat " + trace[i]);  
  
              Throwable ourCause = getCause();  
              if (ourCause != null)  
                  ourCause.printStackTraceAsCause(s, trace);  
          }  
      }  
  
      /** 
       * 打印起因对象的信息 
        */  
      private void printStackTraceAsCause(PrintWriter s,  
                                          StackTraceElement[] causedTrace)  
      {  
          // assert Thread.holdsLock(s);  
  
          // Compute number of frames in common between this and caused  
          StackTraceElement[] trace = getOurStackTrace();  
          int m = trace.length-1, n = causedTrace.length-1;  
          while (m >= 0 && n >=0 && trace[m].equals(causedTrace[n])) {  
              m--; n--;  
          }  
          int framesInCommon = trace.length - 1 - m;  
  
          s.println("Caused by: " + this);  
          for (int i=0; i <= m; i++)  
              s.println("\tat " + trace[i]);  
          if (framesInCommon != 0)  
              s.println("\t... " + framesInCommon + " more");  
  
          // Recurse if we have a cause  
          Throwable ourCause = getCause();  
          if (ourCause != null)  
              ourCause.printStackTraceAsCause(s, trace);  
      }  
  
      /** 
       * 填充异常轨迹 
       */  
      public synchronized native Throwable fillInStackTrace();  
  
      /** 
       * 返回当前的异常轨迹的拷贝 
       */  
      public StackTraceElement[] getStackTrace() {  
          return (StackTraceElement[]) getOurStackTrace().clone();  
      }  
  
      
      /** 
       * 获取当前的异常轨迹 
        */  
      private synchronized StackTraceElement[] getOurStackTrace() {  
         //如果第一次调用此方法则初始化异常轨迹数组  
          if (stackTrace == null) {  
            //获得异常轨迹深度  
              int depth = getStackTraceDepth();  
            //创建新的异常轨迹数组,并填充它  
              stackTrace = new StackTraceElement[depth];  
              
            for (int i=0; i < depth; i++)  
                stackTrace[i] = getStackTraceElement(i);//获取指定位标的异常轨迹  
          }  
          
          return stackTrace;  
      }  
  
      /** 
       * 设置异常轨迹 
       */  
      public void setStackTrace(StackTraceElement[] stackTrace) {  
         //拷贝设置参数  
          StackTraceElement[] defensiveCopy =  
              (StackTraceElement[]) stackTrace.clone();  
          
         //如果设置参数有空元素则抛出异常  
          for (int i = 0; i < defensiveCopy.length; i++)  
              if (defensiveCopy[i] == null)  
                  throw new NullPointerException("stackTrace[" + i + "]");  
  
         //设置当前对象的异常轨迹  
          this.stackTrace = defensiveCopy;  
      }  
  
      /** 
       * 异常轨迹的深度,0表示无法获得 
       */  
      private native int getStackTraceDepth();  
  
      /** 
       * 获取指定位标的异常轨迹 
       */  
      private native StackTraceElement getStackTraceElement(int index);  
  
      
      private synchronized void writeObject(java.io.ObjectOutputStream s)  
          throws IOException  
      {  
          getOurStackTrace();  
          s.defaultWriteObject();  
      }  
}

以上源码分析来自于互联网，同时由于目前是jdk1.8和这个源码有一小部分不一样，但不影响整体分析。当然，我们真正关心的是他的下面几个方法

e.getMessage();”用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:
getCause()：返回抛出异常的原因。如果 cause 不存在或未知，则返回 null。
　 getMeage()：返回异常的消息信息。
　 printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。
而当我们出现异常时，就形成一条异常链，一个一个堆栈的打印出相关信息和异常

快乐源于分享，总结溢于提高

热评文章