【09-异常处理】
|
异常处理 异常概述
•异常处理已经成为衡量一门语言是否成熟的标准之一，目前的主流编程语言如C++、C#、Ruby、 Python等，大都提供了异常处理机制。增加了异常处理机制后的程序有更好的容错性，更加健壮。
传统错误处理的缺陷
•传统错误处理机制，主要如下两个缺点： –无法穷举所有异常情况：因为人类知识的限制，异常情况总比可以考虑到的情况多，总有“漏网之鱼”的异常情况，所以程序总是不够健壮。 –错误处理代码和业务实现代码混杂：这种错误处理和业务实现混杂的代码严重影响程序的可读性，会增加程序维护的难度。
使用try...catch捕获异常
•执行try块里的业务逻辑代码时出现异常，系统自动生成一个异常对象，该异常对象被提交给Java运 行时环境，这个过程被称为抛出（throw）异常。
•Java运行时环境收到异常对象时，会寻找能处理该异常对象的catch块，如果找到合适的catch块并 把该异常对象交给该catch块处理，那这个过程被称为捕获（catch）异常；如果Java运行时环境找 不到捕获异常的catch块，则运行时环境终止，Java程序也将退出。
异常的捕捉流程
Java的异常体系
访问异常信息
•如果程序需要在catch块中访问异常对象的相关信息，可以通过调用catch后异常形参的方法来获 得。当Java运行时决定调用某个catch块来处理该异常对象时，会将该异常对象赋给catch块后的异 常参数，程序就可以通过该参数来获得该异常的相关信息。
•所有异常对象都包含了如下几个常用方法： –getMessage()：返回该异常的详细描述字符串。 –printStackTrace()：将该异常的跟踪栈信息输出到标准错误输出。 –printStackTrace(PrintStream s)：将该异常的跟踪栈信息输出到指定输出流。 –getStackTrace()：返回该异常的跟踪栈信息。
异常处理
try
{
需要检测的代码；
}
catch(异常类 变量)
{
异常处理代码；
}
finally
{
一定会执行的代码；
}
Finally代码块只有一种情况不会被执行。就是在之前执行了System.exit(0)。
Java 7提供的多异常捕捉
•在Java 7以前，每个catch块只能捕捉一个异常。从Java 7开始，一个catch块可以捕捉多个异常。 –catch(异常1 | 异常 2 | 异常3 ex) –{ –} •多个异常之间用竖线隔开。 •多异常捕捉时，异常变量之前有隐式final修饰。
本文原创作者：pipi-changing 本文原创出处：http://www.cnblogs.com/pipi-changing/
使用finally回收资源
•程序在try块里打开了一些物理资源（例如数据库连接、网络连接和磁盘文件等），这些物理资源都 必须显式回收。
•为了保证一定能回收try块中打开的物理资源，异常处理机制提供了finally块。不管try块中的代码是 否出现异常，也不管哪一个catch块被执行，finally块总会被执行。
异常处理的嵌套
•异常处理流程代码可以放在任何能放可执行性代码的地方，因此完整的异常处理流程既可放在try块 里，也可放在catch块里，也可放在finally块里。
•异常处理嵌套的深度没有很明确的限制，但通常没有必要使用超过两层的嵌套异常处理，层次太深的 嵌套异常处理没有太大必要，而且导致程序可读性降低。
Java 7的自动关闭资源的try语句
–try( – // 此处声明的资源， 系统可以自动关闭它。 –) –{ – // –} •对于自动关闭资源的try语句， 可以没有catch和finally——try块可以孤独地存在。 •自动关闭资源的try语句，有两个注意点： –只有放在try后面的圆括号里的资源才会被关闭。 –能被自动关闭的资源必须实现Closeable或AutoCloseable接口。
Checked异常与Runtime异常
•Java的异常被分为两大类：Checked异常和Runtime异常（运行时异常）。所有 RuntimeException类及其子类的实例被称为Runtime异常；不是RuntimeException类及其子类 的异常实例则被称为Checked异常。
Checked异常的处理
•当前方法明确知道如何处理该异常，程序应该使用try...catch块来捕获该异常，然后在对应的catch 块中修改该异常。
•当前方法不知道如何处理这种异常，应该在定义该方法时声明抛出该异常。
Runtime异常的处理
•Runtime异常则更加灵活，Runtime异常无需显式声明抛出。 •如果程序需要捕捉Runtime异常，也可以使用try...catch块来捕捉Runtime异常。
使用throws声明抛出异常
•throws声明抛出异常的思路是：当前方法不知道应该如何这种类型的异常，该异常应该由上一级调 用者处理，如果main方法也不知道应该如何处理这种类型的异常，也可以使用throws声明抛出异 常，该异常将交给JVM处理。JVM对异常的处理方法是：打印异常跟踪栈信息，并中止程序运行，这 就是前面程序在遇到异常后自动结束的原因。
•throws声明抛出只能在方法签名中使用，throws可以声明抛出多个异常类，多个异常类之间以逗 号隔开。throws声明抛出的语法格式如下
–throws ExceptionClass1 , ExceptionClass2...
抛出异常
•如果需要在程序中自行抛出异常，应使用throw语句，throw语句可以单独使用，throw语句抛出 的不是异常类，而是一个异常实例，而且每次只能抛出一个异常实例。throw语句的语法格式如下：
–throw ExceptionInstance; •如果throw语句抛出的异常是Checked异常，则该throw语句要么处于try块里，显式捕获该异常 ，要么放在一个带throws声明抛出的方法中，即把该异常交给该方法的调用者处理。
Java 7增强的throw语句
–try –{ – new FileInputStream(“a.txt”); –} –Catch(Exception ex) –{ – ex.printStackTrace(); – throw ex; //① –} •从JDK 7开始，Java编译器可以只能地识别①号代码处抛出的异常只是FileNotFoundException异常。
自定义异常类
•程序很少会自行抛出系统异常，因为异常的类名通常包含了该异常的有用信息。所以在选择抛出什么 异常时，应该选择合适的异常类，从而可以明确地描述该异常情况。在这种情形下，应用程序常常需要 抛出自定义异常。
•用户自定义异常都应该继承Exception基类，如果希望自定义Runtime异常，则应该继承 RuntimeException基类。定义异常类时通常需要提供两种构造器：一个是无参数的构造器；另一个 是带一个字符串参数的构造器，这个字符串将作为该异常对象的详细说明（也就是异常对象的 getMessage方法的返回值）。
异常链
•当业务逻辑层访问持久层出现SQLException异常时，程序不应该把底层的SQLException异常传 到用户界面，原因有如下两个：
–对于正常用户而言，他们不想看到底层SQLException，SQLException对他们使用该系统没 有任何帮助。 –对于恶意用户而言，将SQLException暴露出来是一种不安全的。
Java的异常跟踪栈
•异常对象的printStackTrace方法用于打印异常的跟踪栈信息，根据printStackTrace方法的输出 结果，我们可以找到异常的源头，并跟踪到异常一路触发的过程。
•面向对象的应用程序运行时，经常会发生一系列方法调用，从而形成“方法调用栈”，异常的传播则与 相反：只要异常没有被完全捕获（包括异常没有被捕获，或异常被处理后重新抛出了新异常），异常从 发生异常的方法逐渐向外传播，首先传给该方法的调用者，该方法调用者再次传给其调用者……直至最 后传到 main方法，如果main方法依然没有处理该异常，JVM会中止该程序，并打印异常的跟踪栈信 息。
异常处理规则
•不要过度使用异常 •不要使用过于庞大的try块 •避免使用Catch All语句 •不要忽略捕获到异常 现在贴出代码：
public class AccessExceptionMsg { public static void main(String[] args) { try { FileInputStream fis = new FileInputStream("a.txt"); } catch (IOException ioe) { System.out.println(ioe.getMessage()); ioe.printStackTrace(); } } }
public class AutoCloseTest { public static void main(String[] args) throws IOException { try ( // 声明、初始化两个可关闭的资源 // try语句会自动关闭这两个资源。 BufferedReader br = new BufferedReader(new FileReader( "AutoCloseTest.java")); PrintStream ps = new PrintStream(new FileOutputStream("a.txt"))) { // 使用两个资源 System.out.println(br.readLine()); ps.println("庄生晓梦迷蝴蝶"); } } }
public class DivTest { public static void main(String[] args) { try { int a = Integer.parseInt(args[0]); int b = Integer.parseInt(args[1]); int c = a / b; System.out.println("您输入的两个数相除的结果是：" + c); } catch (IndexOutOfBoundsException ie) { System.out.println("数组越界：运行程序时输入的参数个数不够"); } catch (NumberFormatException ne) { System.out.println("数字格式异常：程序只能接受整数参数"); } catch (ArithmeticException ae) { System.out.println("算术异常"); } catch (Exception e) { System.out.println("未知异常"); } } }
public class FinallyFlowTest { public static void main(String[] args) throws Exception { boolean a = test(); System.out.println(a); } public static boolean test() { try { // 因为finally块中包含了return语句 // 所以下面的return语句失去作用 return true; } finally { return false; } } }
public class FinallyTest { public static void main(String[] args) { FileInputStream fis = null; try { fis = new FileInputStream("a.txt"); } catch (IOException ioe) { System.out.println(ioe.getMessage()); // return语句强制方法返回 return; // ① // 使用exit来退出虚拟机 // System.exit(1); // ② } finally { // 关闭磁盘文件，回收资源 if (fis != null) { try { fis.close(); } catch (IOException ioe) { ioe.printStackTrace(); } } System.out.println("执行finally块里的资源回收!"); } } }
public class Gobang { // 定义一个二维数组来充当棋盘 private String[][] board; // 定义棋盘的大小 private static int BOARD_SIZE = 15; public void initBoard() { // 初始化棋盘数组 board = new String[BOARD_SIZE][BOARD_SIZE]; // 把每个元素赋为"╋"，用于在控制台画出棋盘 for (int i = 0; i < BOARD_SIZE; i++) { for (int j = 0; j < BOARD_SIZE; j++) { board[i][j] = "╋"; } } } // 在控制台输出棋盘的方法 public void printBoard() { // 打印每个数组元素 for (int i = 0; i < BOARD_SIZE; i++) { for (int j = 0; j < BOARD_SIZE; j++) { // 打印数组元素后不换行 System.out.print(board[i][j]); } // 每打印完一行数组元素后输出一个换行符 System.out.print("\n"); } } public static void main(String[] args) throws Exception { Gobang gb = new Gobang(); gb.initBoard(); gb.printBoard(); // 这是用于获取键盘输入的方法 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String inputStr = null; // br.readLine()：每当在键盘上输入一行内容按回车， // 用户刚刚输入的内容将被br读取到。 while ((inputStr = br.readLine()) != null) { try { // 将用户输入的字符串以逗号作为分隔符，分解成2个字符串 String[] posStrArr = inputStr.split(","); // 将2个字符串转换成用户下棋的坐标 int xPos = Integer.parseInt(posStrArr[0]); int yPos = Integer.parseInt(posStrArr[1]); // 把对应的数组元素赋为"●"。 if (!gb.board[xPos - 1][yPos - 1].equals("╋")) { System.out.println("您输入的坐标点已有棋子了，" + "请重新输入"); continue; } gb.board[xPos - 1][yPos - 1] = "●"; } catch (Exception e) { System.out.println("您输入的坐标不合法，请重新输入，" + "下棋坐标应以x,y的格式"); continue; } gb.printBoard(); System.out.println("请输入您下棋的坐标，应以x,y的格式："); } } }
public class MultiExceptionTest { public static void main(String[] args) { try { int a = Integer.parseInt(args[0]); int b = Integer.parseInt(args[1]); int c = a / b; System.out.println("您输入的两个数相除的结果是：" + c); } catch (IndexOutOfBoundsException | NumberFormatException | ArithmeticException ie) { System.out.println("程序发生了数组越界、数字格式异常、算术异常之一"); // 捕捉多异常时，异常变量默认有final修饰， // 所以下面代码有错： ie = new ArithmeticException("test"); // ① } catch (Exception e) { System.out.println("未知异常"); // 捕捉一个类型的异常时，异常变量没有final修饰 // 所以下面代码完全正确。 e = new RuntimeException("test"); // ② } } }
public class NullTest { public static void main(String[] args) { Date d = null; try { System.out.println(d.after(new Date())); } catch (NullPointerException ne) { System.out.println("空指针异常"); } catch (Exception e) { System.out.println("未知异常"); } } }
public class OverrideThrows { public void test() throws IOException { FileInputStream fis = new FileInputStream("a.txt"); } } class Sub extends OverrideThrows { // 子类方法声明抛出了比父类方法更大的异常 // 所以下面方法出错 public void test() throws Exception { } }
public class ThrowsTest { public static void main(String[] args) throws IOException { FileInputStream fis = new FileInputStream("a.txt"); } }
public class ThrowsTest2 { public static void main(String[] args) throws Exception { // 因为test()方法声明抛出IOException异常， // 所以调用该方法的代码要么处于try...catch块中， // 要么处于另一个带throws声明抛出的方法中。 test(); } public static void test() throws IOException { // 因为FileInputStream的构造器声明抛出IOException异常， // 所以调用FileInputStream的代码要么处于try...catch块中， // 要么处于另一个带throws声明抛出的方法中。 FileInputStream fis = new FileInputStream("a.txt"); } }
public class AuctionException extends Exception { // 无参数的构造器 public AuctionException() { } // ① // 带一个字符串参数的构造器 public AuctionException(String msg) // ② { super(msg); } }
public class AuctionTest { private double initPrice = 30.0; // 因为该方法中显式抛出了AuctionException异常， // 所以此处需要声明抛出AuctionException异常 public void bid(String bidPrice) throws AuctionException { double d = 0.0; try { d = Double.parseDouble(bidPrice); } catch (Exception e) { // 此处完成本方法中可以对异常执行的修复处理， // 此处仅仅是在控制台打印异常跟踪栈信息。 e.printStackTrace(); // 再次抛出自定义异常 throw new AuctionException("竞拍价必须是数值，" + "不能包含其他字符！"); } if (initPrice > d) { throw new AuctionException("竞拍价比起拍价低，" + "不允许竞拍！"); } initPrice = d; } public static void main(String[] args) { AuctionTest at = new AuctionTest(); try { at.bid("df"); } catch (AuctionException ae) { // 再次捕捉到bid方法中的异常。并对该异常进行处理 System.err.println(ae.getMessage()); } } }
public class SalException extends Exception { public SalException() { } public SalException(String msg) { super(msg); } // 创建一个可以接受Throwable参数的构造器 public SalException(Throwable t) { super(t); } }
public class ThrowTest { public static void main(String[] args) { try { // 调用声明抛出Checked异常的方法，要么显式捕获该异常 // 要么在main方法中再次声明抛出 throwChecked(-3); } catch (Exception e) { System.out.println(e.getMessage()); } // 调用声明抛出Runtime异常的方法既可以显式捕获该异常， // 也可不理会该异常 throwRuntime(3); } public static void throwChecked(int a) throws Exception { if (a > 0) { // 自行抛出Exception异常 // 该代码必须处于try块里，或处于带throws声明的方法中 throw new Exception("a的值大于0，不符合要求"); } } public static void throwRuntime(int a) { if (a > 0) { // 自行抛出RuntimeException异常，既可以显式捕获该异常 // 也可完全不理会该异常，把该异常交给该方法调用者处理 throw new RuntimeException("a的值大于0，不符合要求"); } } }
public class ThrowTest { public static void main(String[] args) { try { // 调用声明抛出Checked异常的方法，要么显式捕获该异常 // 要么在main方法中再次声明抛出 throwChecked(-3); } catch (Exception e) { System.out.println(e.getMessage()); } // 调用声明抛出Runtime异常的方法既可以显式捕获该异常， // 也可不理会该异常 throwRuntime(3); } public static void throwChecked(int a) throws Exception { if (a > 0) { // 自行抛出Exception异常 // 该代码必须处于try块里，或处于带throws声明的方法中 throw new Exception("a的值大于0，不符合要求"); } } public static void throwRuntime(int a) { if (a > 0) { // 自行抛出RuntimeException异常，既可以显式捕获该异常 // 也可完全不理会该异常，把该异常交给该方法调用者处理 throw new RuntimeException("a的值大于0，不符合要求"); } } }
public class ThrowTest2 { public static void main(String[] args) // Java 6认为①号代码可能抛出Exception， // 所以此处声明抛出Exception // throws Exception // Java 7会检查①号代码可能抛出异常的实际类型， // 因此此处只需声明抛出FileNotFoundException即可。 throws FileNotFoundException { try { new FileOutputStream("a.txt"); } catch (Exception ex) { ex.printStackTrace(); throw ex; // ① } } }
class SelfException extends RuntimeException { SelfException() { } SelfException(String msg) { super(msg); } } public class PrintStackTraceTest { public static void main(String[] args) { firstMethod(); } public static void firstMethod() { secondMethod(); } public static void secondMethod() { thirdMethod(); } public static void thirdMethod() { throw new SelfException("自定义异常信息"); } }
public class ThreadExceptionTest implements Runnable { public void run() { firstMethod(); } public void firstMethod() { secondMethod(); } public void secondMethod() { int a = 5; int b = 0; int c = a / b; } public static void main(String[] args) { new Thread(new ThreadExceptionTest()).start(); } }
|
浙公网安备 33010602011771号