JAVA面向对象学习——java面向对象概念——Java 异常处理——疯狂java讲义
使用try...catch捕获异常
执行try块里的业务逻辑代码时出现异常，系统自动生成一个异常对象，该异常对象被提交给Java运行时环境，这个过程被称为抛出（throw）异常。
Java运行时环境收到异常对象时，会寻找能处理该异常对象的catch块，如果找到合适的catch块并把该异常对象交给该catch块处理，那这个过程被称为捕获（catch）异常；
如果Java运行时环境找不到捕获异常的catch块，则运行时环境终止，Java程序也将退出。
import java.io.*;
public class Gobang
{
// 定义一个二维数组来充当棋盘
private String[][] board;
// 定义棋盘的大小
private static int BOARD_SIZE = 15;
public void initBoard()
{
// 初始化棋盘数组
board = new String[BOARD_SIZE][BOARD_SIZE];
// 把每个元素赋为"╋"，用于在控制台画出棋盘
for (var i = 0; i < BOARD_SIZE; i++)
{
for (var j = 0; j < BOARD_SIZE; j++)
{
board[i][j] = "╋";
}
}
}
// 在控制台输出棋盘的方法
public void printBoard()
{
// 打印每个数组元素
for (var i = 0; i < BOARD_SIZE; i++)
{
for (var j = 0; j < BOARD_SIZE; j++)
{
// 打印数组元素后不换行
System.out.print(board[i][j]);
}
// 每打印完一行数组元素后输出一个换行符
System.out.print("\n");
}
}
public static void main(String[] args) throws Exception
{
var gb = new Gobang();
gb.initBoard();
gb.printBoard();
// 这是用于获取键盘输入的方法
var 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个字符串转换成用户下棋的坐标
var xPos = Integer.parseInt(posStrArr[0]);
var 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的格式：");
}
}
}
异常的捕捉流程
Java的异常体系
public class DivTest
{
public static void main(String[] args)
{
try
{
var a = Integer.parseInt(args[0]);
var b = Integer.parseInt(args[1]);
var 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("未知异常");
}
}
}
注意：先捕获小异常，再捕获大异常
import java.util.*;
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("未知异常");
}
}
}
访问异常信息
如果程序需要在catch块中访问异常对象的相关信息，可以通过调用catch后异常形参的方法来获得。
当Java运行时决定调用某个catch块来处理该异常对象时，会将该异常对象赋给catch块后的异常参数，程序就可以通过该参数来获得该异常的相关信息。
所有异常对象都包含了如下几个常用方法：
（1）、getMessage()：返回该异常的详细描述字符串。
（2）、printStackTrace()：将该异常的跟踪栈信息输出到标准错误输出。
（3）、printStackTrace(PrintStream s)：将该异常的跟踪栈信息输出到指定输出流。
（4）、getStackTrace()：返回该异常的跟踪栈信息。
import java.io.*;
public class AccessExceptionMsg
{
public static void main(String[] args)
{
try
{
var fis = new FileInputStream("a.txt");
}
catch (IOException ioe)
{
System.out.println(ioe.getMessage());
ioe.printStackTrace();
}
}
}
异常处理
用finally回收资源
有些时候，程序在try块里打开了一些物理资源（例如数据库连接、网络连接和磁盘文件等），这些物理资源都必须显式回收。
提示：Java的垃圾回收机制不会回收任何物理资源，垃圾回收机制只能回收堆内存中对象所占用的内存。
为了保证一定能回收try块中打开的物理资源，异常处理机制提供了finally块。
不管try块中的代码是否出现异常，也不管哪一个catch块被执行，甚至在try块或catch块中执行了return语句，finally块总会被执行。
完整的Java异常处理语法结构如下：
异常处理语法结构中，只有try块是必须的，也就是说，没有try块，则不能有后面的catch块和finally块；
catch块和finally块都是可选的，但catch块和finally块至少出现其中之一，也可以同时出现；
可以有多个catch块，捕获父类异常的catch块，必须位于捕获子类异常的后面；
但不能只有try块，既没有catch块，也没有finally块；
多个catch块必须位于try块之后，finally块必须位于所有的catch块之后。
import java.io.*;
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语句强制方法返回
// System.exit(1); // ② // 使用exit来退出虚拟机
}
finally
{
// 关闭磁盘文件，回收资源
if (fis != null)
{
try
{
fis.close();
}
catch (IOException ioe)
{
ioe.printStackTrace();
}
}
System.out.println("执行finally块里的资源回收!");
}
}
}
上面的程序中，try块后面增加了finally块，用于回收在try块中打开的物理资源。
注意程序的catch块中， ①处有一条return语句，该语句强制方法返回。
在通常情况下，一旦在方法执行到return语句的地方，程序将立即结束该方法；
现在不会了，虽然return语句也强制方法结束，但一定会执行finally块里的代码；
上面运行结果表明方法返回之前，还是执行了finally块里面的语句。
将 ①处语句注释掉，换成②处的语句，即在异常处理的catch块中使用System.exit(1)语句来退出虚拟机，执行得到如下结果：
上面执行结果表明finally块没有被执行。如果在异常处理代码中，使用System.exit(1);语句来退出虚拟机，则finally块将失去执行的机会。
重点：除非在try块、catch块中调用了退出虚拟机的方法，
否则不管在try块、catch块中执行怎么样的代码，出现怎么样的情况，异常处理的finally块总会被执行。
在通常情况下，不要在finally块中使用如return或throw等导致方法终止的语句，（throw语句将在后面介绍），
一旦在finally块中使用了return或throw语句，将会导致try块、catch块中的return、throw语句失效。
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;
}
}
}
上面程序在finally中定义了return false语句，这将导致try块中的return true失去作用。
当 Java 程序执行 try 块、catch 块时遇到了 return 或 throw 语句，这两个语句都会导致该方法立即结束，
但是系统执行这两个语句并不会结束该方法，而是去寻找该异常处理流程中是否包含 finally 块，
如果没有 finally 块，程序立即执行 return 或 throw 语句，方法终止；
如果有 finally 块，系统立即开始执行 finally块——只有当 finally 块执行完成后,系统才会再次跳回来执行 try块,catch块里的 return或 throw语句；
如果 finally 块里也使用了 return 或 throw 等导致方法终止的语句，finally 块已经终止了方法，系统将不会跳回去执行 try 块、catch 块里的任何代码。
注意：尽量避免在 finally 块里使用 return 或 throw 等导致方法终止的语句，否则可能出现一些很奇怪的情况。
Java 7提供的多异常捕捉
在Java 7以前，每个catch块只能捕捉一个异常。
从Java 7开始，一个catch块可以捕捉多个异常。
catch(异常1 | 异常 2 | 异常3 ex)
{
}
多个异常之间用竖线隔开。 多异常捕捉时，异常变量之前有隐式final修饰。
public class MultiExceptionTest
{
public static void main(String[] args)
{
try
{
var a = Integer.parseInt(args[0]);
var b = Integer.parseInt(args[1]);
var 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"); // ②
}
}
}
异常处理的嵌套
异常处理流程代码可以放在任何能放可执行性代码的地方，因此完整的异常处理流程既可放在try块里，也可放在catch块里，也可放在finally块里。
异常处理嵌套的深度没有很明确的限制，但通常没有必要使用超过两层的嵌套异常处理，层次太深的嵌套异常处理没有太大不要，而且导致程序可读性降低。
Java 9的自动关闭资源的try语句
try
(
// 此处声明的资源， 系统可以自动关闭它。
)
{
//
}
对于自动关闭资源的try语句， 可以没有catch和finally——try块可以孤独地存在。
Java 9允许在圆括号之外声明、创建资源，只要在圆括号里列出需要自动关闭的资源即可，多个资源之间用英文逗号隔开。
自动关闭资源的try语句，有两个注意点：
（1）、只有放在try后面的圆括号里的资源才会被关闭。
（2）、能被自动关闭的资源必须实现Closeable或AutoCloseable接口。
java7示例：
import java.io.*;
public class AutoCloseTest
{
public static void main(String[] args) throws IOException
{
try (
// 声明、初始化两个可关闭的资源
// try语句会自动关闭这两个资源。
var br = new BufferedReader( new FileReader("AutoCloseTest.java"));
var ps = new PrintStream(new FileOutputStream("a.txt")))
{
// 使用两个资源
System.out.println(br.readLine());
ps.println("庄生晓梦迷蝴蝶");
}
}
}
自动关闭资源的try语句相当于包含了隐式的finally块（这个finally块用于关闭资源），因此这个try语句可以既没有catch块，也没有finally块。
java9再次增强了这种try语句，java9不要求在try后的圆括号内声明并创建资源，只需要自动关闭的资源有final修饰或者是有效的final，
java9允许将资源变量放在try后的圆括号内；
java9示例：
import java.io.*;
public class AutoCloseTest2
{
public static void main(String[] args) throws IOException
{
// 有final修饰的资源
final var br = new BufferedReader(new FileReader("AutoCloseTest.java"));
// 没有显式使用final修饰，但只要不对该变量重新赋值，按该变量就是有效的final
var ps = new PrintStream(new FileOutputStream("a.txt"));
// 只要将两个资源放在try后的圆括号内即可
try (br; ps)
{
// 使用两个资源
System.out.println(br.readLine());
ps.println("庄生晓梦迷蝴蝶");
}
}
}
浙公网安备 33010602011771号