String str

小说:创业找项目致富经作者:邓宗密建更新时间:2019-03-20字数:58204

String str


一、异常概述

  

  异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。比如说,你的代码少了一个分号,那么运行出来结果是提示是错误 java.lang.Error;如果你用System.out.println(11/0),那么你是因为你用0做了除数,会抛出 java.lang.ArithmeticException 的异常。

  异常发生的原因有很多,通常包含以下几大类:

  • 用户输入了非法数据。
  • 要打开的文件不存在。
  • 网络通信时连接中断,或者JVM内存溢出。

  这些异常有的是因为用户错误引起,有的是程序错误引起的,还有其它一些是因为物理错误引起的,为增强程序的健壮性,计算机程序的编写也需要考虑处理这些异常情况,Java语言提供了异常处理功能,本文将介绍Java异常处理机制。

  为了更好的理解和学习Java异常处理机制,首先看看下面程序:

//HelloWorld.java文件
package com.Kevin;

public class HelloWorld {

    public static void main(String[] args) {
        int a = 0;
        System.out.println(5 / a);
    }
}

这个程序没有编译错误,但会发生如下的运行时错误:

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at com.Kevin.HelloWorld.main(HelloWorld.java:9)

在数学上除数不能为0,所以程序运行时表达式(5 / a)会抛出ArithmeticException异常,ArithmeticException是数学计算异常,凡是发生数学计算错误都会抛出该异常。

  程序运行过程中难免会发生异常,发生异常并不可怕,程序员应该考虑到有可能发生这些异常,编程时应该捕获并进行处理异常,不能让程序发生终止,这就是健壮的程序。

 

二、异常类继承层次

  所有的异常类是从 java.lang.Exception 类继承的子类。Exception 类是 Throwable 类的子类。除了Exception类外,Throwable还有一个子类Error 。Java 程序通常不捕获错误。错误一般发生在严重故障时,它们在Java程序处理的范畴之外。Error 用来指示运行时环境发生的错误。例如,JVM 内存溢出。一般地,程序不会从错误中恢复。异常类有两个主要的子类:IOException 类和 RuntimeException 类。Java的异常类继承层次具体如下图:

                Java异常类继承层次图

 

2.1 Throwable类

  从Java异常类继承层次图可见,所有的异常类都直接或间接地继承于java.lang.Throwable类,在Throwable类有几个非常重要的方法:

  • String getMessage():获得发生异常的详细消息。
  • void printStackTrace():打印异常堆栈跟踪信息。
  • String toString():获得异常对象的描述。

 

  为了介绍Throwable类的使用,示例代码如下:

 1 //HelloWorld.java文件
 2 package com.Kevin;
 3 
 4 public class HelloWorld {
 5 
 6     public static void main(String[] args) {
 7 
 8         int a = 0;
 9         int result = divide(5, a);
10         System.out.printf("divide(%d, %d) = %d", 5, a, result);
11     }
12 
13     public static int divide(int number, int divisor) {
14 
15         try {
16             return number / divisor;
17         } catch (Throwable throwable) {                                        
18 
19             System.out.println("getMessage() : " + throwable.getMessage());    
20 
21             System.out.println("toString() : " + throwable.toString());        
22 
23             System.out.println("printStackTrace()输出信息如下:");
24             throwable.printStackTrace();                                       
25         }
26 
27         return 0;
28     }
29 }

运行结果如下:

getMessage() : / by zero
toString() : java.lang.ArithmeticException: / by zero
printStackTrace()输出信息如下:
java.lang.ArithmeticException: / by zero
    at com.Kevin.HelloWorld.divide(HelloWorld.java:17)
    at com.Kevin.HelloWorld.main(HelloWorld.java:10)
divide(5, 0) = 0

将可以发生异常的语句System.out.println(5 / a)放到try-catch代码块中,称为捕获异常,有关捕获异常的相关知识会在下部分详细介绍。在catch中有一个Throwable对象throwable,throwable对象是系统在程序发生异常时创建,通过throwable对象可以调用Throwable中定义的方法。

  代码第19行是调用getMessage()方法获得异常消息,输出结果是“/ by zero”。代码第21行是调用toString()方法获得异常对象的描述,输出结果是java.lang.ArithmeticException: / by zero。代码第24行是调用printStackTrace()方法打印异常堆栈跟踪信息。

 

Tips: 堆栈跟踪信息从下往上,是方法调用的顺序。首先JVM调用是 com.Kevin.HelloWorld 类的main方法,接着在HelloWorld.java源代码第10行调用 com.Kevin.HelloWorld 类的 divide 方法,在HelloWorld.java 源代码第17行发生了异常,最后输出的是异常信息。

 

2.2 Error 和 Exception

从Java异常类继承层次图可见,Throwable有两个直接子类:Error和Exception。

  1. Error:Error 是程序无法恢复的严重错误,程序员根本无能为力,只能让程序终止。例如:JVM内部错误、内存溢出和资源耗尽等严重情况。

  2. Exception:Exception 是程序可以恢复的异常,它是程序员所能掌控的。例如:除零异常、空指针访问、网络连接中断和读取不存在的文件等。本章所讨论的异常处理就是对Exception及其子类的异常处理。

 

2.3 受检查异常和运行时异常

  从Java异常类层次图可见,Exception类可以分为:受检查异常和运行时异常。

  1. 受检查异常

    如Java异常类层次图所示,受检查异常是除 RuntimeException 以外的异常类。它们的共同特点是:编译器会检查这类异常是否进行了处理,即要么捕获(try-catch语句),要么不抛出(通过在方法后声明throws),否则会发生编译错误。它们种类很多,前面遇到过的日期解析异常 ParseException。

  2. 运行时异常

    运行时异常是继承 RuntimeException 类的直接或间接子类。运行时异常往往是程序员所犯错误导致的,健壮的程序不应该发生运行时异常。它们的共同特点是:编译器不检查这类异常是否进行了处理,也就是对于这类异常不捕获也不抛出,程序也可以编译通过。由于没有进行异常处理,一旦运行时异常发生就会导致程序的终止,这是用户不希望看到的。由于2.1部分除零示例的ArithmeticException异常属于RuntimeException异常,如Java异常类层次图所示,可以不用加try-catch语句捕获异常。

//HelloWorld.java文件
package com.Kevin;
 
public class HelloWorld {
 
    public static void main(String[] args) {
 
        int a = 0;
        int result = divide(5, a);
        System.out.printf("divide(%d, %d) = %d", 5, a, result);
    }
 
    public static int divide(int number, int divisor) {
 
        //判断除数divisor非零,防止运行时异常
        if (divisor != 0) {
            return number / divisor;
        }
        return 0;
    }
 
}

Tips: 对于运行时异常通常不采用抛出或捕获处理方式,而是应该提前预判,防止这种发生异常,做到未雨绸缪。例如2.1部分除零示例,在进行除法运算之前应该判断除数是非零的,修改示例代码如下,从代码可见提前预判这样处理要比通过try-catch捕获异常要友好的多。

 

2.4 Java常用内置异常

  Java 语言定义了一些异常类在 java.lang 标准包中。标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的,所以大部分从运行时异常类继承而来的异常都可以直接使用。Java 根据各个类库也定义了一些其他的异常,下面的表中列出了 Java 的非检查性异常。

 

下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类。

 

Tips: 

  • 检查性异常: 不处理编译不能通过
  • 非检查性异常:不处理编译可以通过,如果有抛出直接抛到控制台
  • 运行时异常: 就是非检查性异常
  • 非运行时异常: 就是检查性异常

 

5.常见异常方法

下面的列表是 Throwable 类的主要方法:

 

6.通用异常

在Java中定义了两种类型的异常和错误。

  • JVM(Java虚拟机) 异常:由 JVM 抛出的异常或错误。例如:NullPointerException 类,ArrayIndexOutOfBoundsException 类,ClassCastException 类。
  • 程序级异常:由程序或者API程序抛出的异常。例如 IllegalArgumentException 类,IllegalStateException 类。

 

三、捕获异常

  在学习本内容之前,你先考虑一下,在现实生活中是如何对待领导交给你的任务呢?当然无非是两种:自己有能解决的自己处理;自己无力解决的反馈给领导,让领导自己处理。

  那么对待受检查异常亦是如此。当前方法有能力解决,则捕获异常进行处理;没有能力解决,则抛出给上层调用方法处理。如果上层调用方法还无力解决,则继续抛给它的上层调用方法,异常就是这样向上传递直到有方法处理它,如果所有的方法都没有处理该异常,那么JVM会终止程序运行。

 

3.1 try-catch 语句

  捕获异常是通过try-catch语句实现的,最基本try-catch语句语法如下:

try{
    //可能会发生异常的语句
} catch(Throwable e){
    //处理异常e
}

  

  每个try代码块可以伴随一个或多个catch代码块,用于处理try代码块中所可能发生的多种异常。catch(Throwable e)语句中的e是捕获异常对象,e必须是Throwable的子类,异常对象e的作用域在该catch代码块中。下面看看一个try-catch示例:

 1 //HelloWorld.java文件
 2 package com.Kevin;
 3  
 4 import java.text.DateFormat;
 5 import java.text.ParseException;
 6 import java.text.SimpleDateFormat;
 7 import java.util.Date;
 8  
 9 public class HelloWorld {
10  
11     public static void main(String[] args) {
12         Date date = readDate();
13         System.out.println("日期  = " + date);
14     }
15  
16     // 解析日期
17     public static Date readDate() {                   
18  
19         try {
20             String str = "2018-4-28";     //"201A-18-18"
21             DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
22             // 从字符串中解析日期
23             Date date = df.parse(str);                
24             return date;
25         } catch (ParseException e) {                  
26             System.out.println("处理ParseException…");
27             e.printStackTrace();                      
28         }
29         return null;
30     }
31 }

上述代码第17行定义了一个静态方法用来将字符串解析成日期,但并非所有的字符串都是有效的日期字符串,因此调用代码第23行的解析方法parse()有可能发生ParseException异常,ParseException是受检查异常,在本例中使用try-catch捕获。代码第25行的e就是ParseException对象。代码第27行e.printStackTrace()是打印异常堆栈跟踪信息,本例中的"2018-4-28"字符串是有个有效的日期字符串,因此不会发生异常。如果将字符串改为无效的日期字符串,如"201A-18-18",则会打印信息。

处理ParseException
java.text.ParseException: Unparseable date: "201A-18-18"
日期  = null
    at java.text.DateFormat.parse(Unknown Source)
    at com.Kevin.HelloWorld.readDate(HelloWorld.java:24)
    at com.Kevin.HelloWorld.main(HelloWorld.java:13)

 

Tips: 静态方法、实例方法和构造方法都可以声明抛出异常,凡是抛出异常的方法都可以通过try-catch进行捕获,当然运行时异常可以不捕获。一个方法声明抛出什么样的异常需要查询API文

 

3.2 多catch代码块

  如果try代码块中有很多语句会发生异常,而且发生的异常种类又很多。那么可以在try后面跟有多个catch代码块。多catch代码块语法如下:

try{
    //可能会发生异常的语句
} catch(Throwable e){
    //处理异常e
} catch(Throwable e){
    //处理异常e
} catch(Throwable e){
    //处理异常e
}

在多个catch代码情况下,当一个catch代码块捕获到一个异常时,其他的catch代码块就不再进行匹配。

Tips: 当捕获的多个异常类之间存在父子关系时,捕获异常顺序与catch代码块的顺序有关。一般先捕获子类,后捕获父类,否则子类捕获不到。

示例代码如下:

 1 //HelloWorld.java文件
 2 package com.Kevin;
 3 
 4 ……
 5 
 6 public class HelloWorld {
 7 
 8     public static void main(String[] args) {
 9         Date date = readDate();
10         System.out.println("读取的日期  = " + date);
11     }
12 
13     public static Date readDate() {
14 
15         FileInputStream readfile = null;
16         InputStreamReader ir = null;
17         BufferedReader in = null;
18         try {
19             readfile = new FileInputStream("readme.txt");      
20             ir = new InputStreamReader(readfile);
21             in = new BufferedReader(ir);
22             // 读取文件中的一行数据
23             String str = in.readLine();                        
24             if (str == null) {
25                 return null;
26             }
27 
28             DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
29             Date date = df.parse(str);                         
30             return date;
31 
32         } catch (FileNotFoundException e) {                    
33             System.out.println("处理FileNotFoundException...");
34             e.printStackTrace();
35         } catch (IOException e) {                              
36             System.out.println("处理IOException...");
37             e.printStackTrace();
38         } catch (ParseException e) {                           
39             System.out.println("处理ParseException...");
40             e.printStackTrace();
41         }
42         return null;
43     }
44 
45 }

上述代码通过Java I/O(输入输出)流技术从文件readme.txt中读取字符串,然后解析成为日期。由于Java I/O技术还没有介绍,读者先不要关注I/O技术细节,这考虑调用它们的方法会发生异常就可以了。

在try代码块中第19行代码调用FileInputStream构造方法可以会发生FileNotFoundException异常。第23行代码调用BufferedReader输入流的readLine()方法可以会发生IOException异常。从Java异常类继承层次图可见FileNotFoundException异常是IOException异常的子类,应该先FileNotFoundException捕获,见代码第32行;后捕获IOException,见代码第35行。

如果将FileNotFoundException和IOException捕获顺序调换,代码如下:

try{
    //可能会发生异常的语句
} catch (IOException e) {
    // IOException异常处理
} catch (FileNotFoundException e) {
    // FileNotFoundException异常处理
}

那么第二个catch代码块永远不会进入,FileNotFoundException异常处理永远不会执行。

由于上述代码第38行ParseException异常与IOException和FileNotFoundException异常没有父子关系,捕获ParseException异常位置可以随意放置。

 

3.3 try-catch 语句嵌套

  Java提供的try-catch语句嵌套是可以任意嵌套,修改3.2部分示例代码如下:

 1 //HelloWorld.java文件
 2 package com.Kevin;
 3 … …
 4 public class HelloWorld {
 5 
 6     public static void main(String[] args) {
 7         Date date = readDate();
 8         System.out.println("读取的日期  = " + date);
 9     }
10 
11     public static Date readDate() {
12 
13         FileInputStream readfile = null;
14         InputStreamReader ir = null;
15         BufferedReader in = null;
16         try {
17             readfile = new FileInputStream("readme.txt");
18             ir = new InputStreamReader(readfile);
19             in = new BufferedReader(ir);
20 
21             try {                                                  
22                 String str = in.readLine();                        
23                 if (str == null) {
24                     return null;
25                 }
26 
27                 DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
28                 Date date = df.parse(str);                         
29                 return date;
30 
31             } catch (ParseException e) {
32                 System.out.println("处理ParseException...");
33                 e.printStackTrace();
34             }                                                      
35 
36         } catch (FileNotFoundException e) {                        
37             System.out.println("处理FileNotFoundException...");
38             e.printStackTrace();
39         } catch (IOException e) {                                  
40             System.out.println("处理IOException...");
41             e.printStackTrace();
42         }
43         return null;
44     }
45 }

上述代码第21~34行是捕获ParseException异常try-catch语句,可见这个try-catch语句就是嵌套在捕获IOException和FileNotFoundException异常的try-catch语句中。

程序执行时内层如果会发生异常,首先由内层catch进行捕获,如果捕获不到,则由外层catch捕获。例如:代码第22行的readLine()方法可能发生IOException异常,该异常无法被内层catch捕获,最后被代码第39行的外层catch捕获。

Tips: try-catch不仅可以嵌套在try代码块中,还可以嵌套在catch代码块或finally代码块,finally代码块后面会详细介绍。try-catch嵌套会使程序流程变的复杂,如果能用多catch捕获的异常,尽量不要使用try-catch嵌套。特别对于初学者不要简单地使用Eclipse的语法提示不加区分地添加try-catch嵌套,要梳理好程序的流程再考虑try-catch嵌套的必要性。

 

3.4 多重捕捉

  多catch代码块客观上提高了程序的健壮性,但是程序代码量大大增加。如果有些异常虽然种类不同,但捕获之后的处理是相同的,看如下代码。

try{
    //可能会发生异常的语句
} catch (FileNotFoundException e) {
    //调用方法methodA处理
} catch (IOException e) {
    //调用方法methodA处理
} catch (ParseException e) {
    //调用方法methodA处理
}

三个不同类型的异常,要求捕获之后的处理都是调用methodA方法。是否可以把这些异常合并处理,Java 7推出了多重捕获(multi-catch)技术,可以帮助解决此类问题,上述代码修改如下:

try{
    //可能会发生异常的语句
} catch (IOException | ParseException e) {
    //调用方法methodA处理
}

在catch中多重捕获异常用“|”运算符连接起来。

Tips: 有的读者会问什么不写成FileNotFoundException | IOException | ParseException 呢?这是因为由于FileNotFoundException属于IOException异常,IOException异常可以捕获它的所有子类异常了。

 

四、释放资源

  有时在try-catch语句中会占用一些非Java资源,如:打开文件、网络连接、打开数据库连接和使用数据结果集等,这些资源并非Java资源,不能通过JVM的垃圾收集器回收,需要程序员释放。为了确保这些资源能够被释放可以使用finally代码块或Java 7之后提供自动资源管理(Automatic Resource Management)技术。

 

4.1 finally 代码块

try-catch语句后面还可以跟有一个finally代码块,try-catch-finally语句语法如下:

try{
    //可能会生成异常语句
} catch(Throwable e1){
    //处理异常e1
} catch(Throwable e2){
    //处理异常e2
} catch(Throwable eN){
    //处理异常eN
} finally{
    //释放资源
}

无论try正常结束还是catch异常结束都会执行finally代码块,如下图所示:

              

使用finally代码块示例代码如下:

 1 //HelloWorld.java文件
 2 package com.Kevin;
 3 
 4 … …
 5 
 6 public class HelloWorld {
 7 
 8     public static void main(String[] args) {
 9         Date date = readDate();
10         System.out.println("读取的日期  = " + date);
11     }
12 
13     public static Date readDate() {
14 
15         FileInputStream readfile = null;
16         InputStreamReader ir = null;
17         BufferedReader in = null;
18         try {
19             readfile = new FileInputStream("readme.txt");
20             ir = new InputStreamReader(readfile);
21             in = new BufferedReader(ir);
22             // 读取文件中的一行数据
23             String str = in.readLine();
24             if (str == null) {
25                 return null;
26             }
27 
28             DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
29             Date date = df.parse(str);
30             return date;
31 
32         } catch (FileNotFoundException e) {
33             System.out.println("处理FileNotFoundException...");
34             e.printStackTrace();
35         } catch (IOException e) {
36             System.out.println("处理IOException...");
37             e.printStackTrace();
38         } catch (ParseException e) {
39             System.out.println("处理ParseException...");
40             e.printStackTrace();
41         } finally {                              
42             try {
43                 if (readfile != null) {
44                     readfile.close();            
45                 }
46             } catch (IOException e) {
47                 e.printStackTrace();
48             }
49             try {
50                 if (ir != null) {
51                     ir.close();                  
52                 }
53             } catch (IOException e) {
54                 e.printStackTrace();
55             }
56             try {
57                 if (in != null) {
58                     in.close();                  
59                 }
60             } catch (IOException e) {
61                 e.printStackTrace();
62             }
63         }                                        
64 
65         return null;
66     }
67 }

上述代码第41行~第63行是finally语句,在这里通过关闭流释放资源,FileInputStream、InputStreamReader和BufferedReader是三个输入流,它们都需要关闭,见代码第44行~第58行通过流的close()关闭流,但是流的close()方法还有可以能发生 IOException 异常,所以这里又针对每一个close()语句还需要进行捕获处理。

Tips: 为了代码简洁等目的,可能有的人会将finally代码中的多个嵌套的try-catch语句合并,例如将上述代码改成如下形式,将三个有可以发生异常的close()方法放到一个try-catch。读者自己考虑一下这处理是否稳妥呢?每一个close()方法对应关闭一个资源,如果第一个close()方法关闭时发生了异常,那么后面的两个也不会关闭,因此如下的程序代码是有缺陷的。

 

try {
    ... ...
} catch (FileNotFoundException e) {
    ... ...
} catch (IOException e) {
    ... ...
} catch (ParseException e) {
    ... ...
} finally {
    try {
        if (readfile != null) {
            readfile.close();
        }
        if (ir != null) {
            ir.close();
        }
        if (in != null) {
            in.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

 

4.2 自动资源管理

  4.1部分使用finally代码块释放资源会导致程序代码大量增加,一个finally代码块往往比正常执行的程序还要多。在Java 7之后提供自动资源管理(Automatic Resource Management)技术,可以替代finally代码块,优化代码结构,提高程序可读性。自动资源管理是在try语句上的扩展,语法如下:

try (声明或初始化资源语句) {
    //可能会生成异常语句
} catch(Throwable e1){
    //处理异常e1
} catch(Throwable e2){
    //处理异常e1
} catch(Throwable eN){
    //处理异常eN
}

在try语句后面添加一对小括号“()”,其中是声明或初始化资源语句,可以有多条语句语句之间用分号“;”分隔。

示例代码如下:

 1 //HelloWorld.java文件
 2 package com.Kevin;
 3 … …
 4 public class HelloWorld {
 5 
 6     public static void main(String[] args) {
 7         Date date = readDate();
 8         System.out.println("读取的日期  = " + date);
 9     }
10 
11     public static Date readDate() {
12 
13         // 自动资源管理
14         try (FileInputStream readfile = new FileInputStream("readme.txt");     
15                 InputStreamReader ir = new InputStreamReader(readfile);        
16                 BufferedReader in = new BufferedReader(ir)) {                  
17 
18             // 读取文件中的一行数据
19             String str = in.readLine();
20             if (str == null) {
21                 return null;
22             }
23 
24             DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
25             Date date = df.parse(str);
26             return date;
27 
28         } catch (FileNotFoundException e) {
29             System.out.println("处理FileNotFoundException...");
30             e.printStackTrace();
31         } catch (IOException e) {
32             System.out.println("处理IOException...");
33             e.printStackTrace();
34         } catch (ParseException e) {
35             System.out.println("处理ParseException...");
36             e.printStackTrace();
37         }
38 
39         return null;
40     }
41 
42 }

上述代码第14行~第16行是声明或初始化三个输入流,三条语句放到在try??

当前文章:http://cnsdbtzg.com/ask/question_50178.html

发布时间:2019-03-20 10:53:56

有没有类似桔子兼职和敲宝网的网站 巨财易赚金在哪里注册 如何一天赚1000块钱 酷我音乐听歌赚钱app 游戏赚钱软件提现金 疯狂赚钱app 手机下软件赚佣金 多利微宝签到中心 网络兼职赚钱 宣传语 米哆店铺最新版本

54839 95224 55581 35828 45727 6061820051 90390 55735

我要说两句: (0人参与)

发布