Java的异常处理——try-catch-finally-throw-throws
大一大二写了两年C++，好几万行的代码，从来没有写过异常处理方面的代码。C++的老师上课放过异常处理的PPT，但是没有布置过相关作业，平时写的代码也不会想去用异常处理。现在到了大三上学期，才第一次在数据库课程设计的程序中写了try-catch。本学期学Java，我要彻底弄清楚异常处理是怎么弄的。
try-catch
下面的例子：多catch处理语句。一个catch捕获一个异常。出现异常的时候：停止try，按照代码里 catch 的顺序从上往下依次匹配异常类型，首次匹配成功后执行该 catch，后面的 catch 跳过，不用继续匹配。如果 catch 的顺序是：先捕获异常 e1, 其后面再捕获异常 e2，那么 e1 不能是 e2 父类。即父类异常要在子类异常的后面捕获。
其实在 catch { } 里面，理论上也可能抛出异常。写 catch 的时候要小心，保证不要出问题。如果在 catch 里面抛出了异常，那就hehe了。
package exception;
import java.util.Scanner;
public class MultiCatchDemo
{
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
int array[] = new int[3];
try
{
System.out.println("input a number");
String str = scanner.next();
int n1 = Integer.parseInt(str); // str 转换成 int, 可能抛出 NumberFormatException
System.out.println("input another number");
int n2 = scanner.nextInt();
array[1] = n1 / n2; // n2 等于 0 时，抛出ArithmeticException
array[3] = n1 * n2; // 数组越界，抛出ArrayIndexOutOfBoundsException
System.out.println("the sum of two numbers is" + (n1 + n2));
}
catch (NumberFormatException ex)
{
System.out.println("数字格式化异常");
}
catch (ArithmeticException ex)
{
System.out.println("算术异常");
}
catch (ArrayIndexOutOfBoundsException ex)
{
System.out.println("数组下标越界异常");
}
catch (Exception e)
{
System.out.println("其他未知异常");
}
scanner.close(); // 物理资源回收
System.out.println("程序结束");
}
}
在Java 7中，增加了多异常捕获，即一个catch可以同时捕获多个不同类型的异常。这个异常对象是final，其引用不能指向一个另外一个异常对象。
catch (ArrayIndexOutOfBoundsException | NumberFormatException | ArithmeticException ex)
{
System.out.println("程序发生了数组越界，数字格式异常，算数异常之一");
// ex = new ArithmeticException("text"); 默认是常数，不能赋值
}try-catch是可以嵌套的。需要注意的是：内层try抛出的异常，如果内层没有catch的话，由外层catch负责捕获。
package exception;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Scanner;
public class NestingTryCatch
{
public static void main(String[] args)
{
// 外层try
try(Scanner scanner = new Scanner(System.in)) // 自动关闭资源
{
System.out.println("input one number");
String str = scanner.next();
int n1 = Integer.parseInt(str);
// 内层try
try
{
@SuppressWarnings({ "unused", "resource" })
FileInputStream fis = new FileInputStream("caitao.txt");
}
catch (IOException ioe)
{
System.out.println(ioe.getMessage());
}
System.out.println("input another number");
int n2 = scanner.nextInt();
System.out.println("n1/n2 = " + n1 / n2);
}
catch (Exception e)
{
e.printStackTrace();
}
System.out.println("caitao");
}
}
try-catch-finally
fianlly的作用一般是回收物理资源，比如：数据库连接，网络连接，磁盘文件读写等等。如果在try里面使用了物力资源，不管是否发生异常，都应该回收这些资源。不管是否发生异常，fianlly代码块里面的代码总会执行。Java的垃圾回收机制可以回收堆内存中对象占用的内存（也就是 new 操作符的东西），但是不能回收物理资源。
package exception;
import java.io.FileInputStream;
import java.io.IOException;
public class FinallyDemo
{
public static void main(String[] args)
{
FileInputStream fis = null;
try
{
fis = new FileInputStream("caitao.txt");
}
catch (IOException ioe)
{
System.out.println(ioe.getMessage());
return;
//System.exit(0);
}
finally
{
if (fis != null)
{
try
{
fis.close();
}
catch (IOException ioe)
{
ioe.printStackTrace();
}
}
System.out.println("执行finally块里的资源回收");
}
}
}
从 Java 7 开始，try后面可以加一对圆括号，在这个圆括号里面，可以声明，初始化一个或多个资源。当 try 语句结束的时候，可以自动关闭资源。这样就不用finally，不用手动写 scanner.close() 了，JVM会自动帮我们做。
try(Scanner scanner = new Scanner(System.in))
{
}
catch ()
{
}
// 隐式的finally块，自动关闭资源throw & throws
throw 抛出一个异常对象：程序出现异常的时候，系统会自动抛出异常对象，除此之外也可以用代码手动抛出异常对象（比如抛出自己写的一个异常类的对象，或者根据业务需要抛出异常对象）
package exception;
import java.util.Scanner;
public class ThrowDemo
{
public static void main(String[] args)
{
try(Scanner scanner = new Scanner(System.in))
{
System.out.println("input your age: ");
int age = scanner.nextInt();
if (age < 0 || age > 100) // 年龄超出范围则抛出异常
{
throw new Exception("age is unlegal");
}
}
catch (Exception e)
{
e.printStackTrace();
}
System.out.println("程序结束");
}
}
throws 声明抛出一个异常序列：在定义方法的时候使用。假设定义了方法foo( )，foo( )方法内部可能抛出异常MyException，但是foo( ) 内部没有catch MyException。于是定义 foo( ) throws MyException { }。这样 MyException 对象就由调用foo( ) 的上一级调用者进行处理。如果存在多级调用，“下面一级”抛出了一个异常对象，“上一级”捕获了，那么“更上一级”就无法捕获了，毕竟异常对象只有一个。
package exception;
import java.util.Scanner;
public class ThrowsDemo
{
public static void myThrowsFunction() throws NumberFormatException, ArithmeticException, Exception
{ // 这个方法可能抛出异常，但是没有自己处理。“甩锅”给上一级调用者
Scanner scanner = new Scanner(System.in);
System.out.println("input a number");
String string = scanner.next();
int n1 = Integer.parseInt(string);
System.out.println("input another number");
int n2 = scanner.nextInt();
System.out.println("n1/n2 = " + n1 / n2);
scanner.close();
}
public static void main(String[] args)
{
try
{
myThrowsFunction();
// 这个方法可能抛出异常，但是这个方法自己却没有处理。于是交给上一级(即 main 方法)处理
}
catch (NumberFormatException e)
{
e.printStackTrace();
}
catch (ArithmeticException e)
{
e.printStackTrace();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
自定义一个异常类
从 java.lang.Exception 可以继承一个检查型自定义类，也可以从 java.lang.RuntimeException 继承一个非检查型异常。
Exception类的构造方法有：super( )，和 super( String message ) 两种。
package exception;
@SuppressWarnings("serial")
class MyException extends Exception
{
private int i;
public int val()
{
return i;
}
public MyException(){}
public MyException(String msg)
{
super(msg);
}
public MyException(String msg, int i)
{
super(msg);
this.i = i;
}
}
public class MyExceptionDemo
{
public static void a() throws MyException
{
System.out.println("Throwing MyException from a()");
throw new MyException();
}
public static void b() throws MyException
{
System.out.println("Throwing MyException from b()");
throw new MyException("Originated in b()");
}
public static void c() throws MyException
{
System.out.println("Throwing MyException from c()");
throw new MyException("Originated in c()", 43);
}
public static void main(String[] args)
{
try
{
a();
}
catch (MyException e)
{
e.getMessage();
}
try
{
b();
}
catch (MyException e)
{
e.toString();
}
try
{
c();
}
catch (MyException e)
{
e.printStackTrace();
System.out.println("error code: " + e.val());
}
}
}