一.java的异常，只要catch住异常了，程序就不会挂，依然会执行catch之后的语句
Java程序发生异常就挂了吗？
为了验证程序不会挂，我写了个例子给大家看看。
测试代码：
import java.io.File;
import java.io.IOException;
/**
* Java程序发生异常就挂了吗？
*
*/
publicclass TestException {
publicstaticvoid main(String[] args) {
TestException te = new TestException();
String s = te.test();
System.out.println(s);
}
/**
* 这个方法有异常，看看异常发生时候会不会执行到底，会不会返回个值？
*
* @return 一个字符串！
*/
public String test() {
System.out.println(">>>> start");
try {
test1();
File f = null;
f.delete();
// int x = 10;
// int y = 0;
// int z = x / y;
System.out.println("计算完成了！");
} catch (Exception e) {
System.out.println("出异常挂了我如何处理呢？");
System.out.println(e);
} finally {
System.out.println("最后总要做的一件事。。。");
}
System.out.println(">>>> end");
return"good!";
}
/**
* 抛个比较猛烈的异常看看程序会挂吗？
*
* @throws IOException
*/
publicvoid test1() throws IOException {
thrownew IOException();
}
}
运行结果：
>>>> start
出异常挂了我如何处理呢？
java.io.IOException
最后总要做的一件事。。。
>>>> end
good!
Process finished with exit code 0
换个异常运行看看：
>>>> start
出异常挂了我如何处理呢？
java.lang.NullPointerException
最后总要做的一件事。。。
>>>> end
good!
Process finished with exit code 0
再换个控制针看看：
>>>> start
出异常挂了我如何处理呢？
java.lang.ArithmeticException: / by zero
最后总要做的一件事。。。
>>>> end
good!
Process finished with exit code 0
结果表明：程序仅仅跳过了try中发生异常以后的代码，在发生异常时候执行了处理语句块catch，在catch执行结束后接着执行了finally语句块，然后继续执行try...catch...finally之外的语句块。
---------------------
作者：zcywell
来源：CSDN
原文：https://blog.csdn.net/zcywell/article/details/7452952
版权声明：本文为博主原创文章，转载请附上博文链接！
二.spring web的异常
无论程序怎么抛，在mvc controller中哪怕没有catch异常，你会发现web程序依然没有挂掉，那必然是有个地方做了catch住，否则程序会挂掉的。这就是spring mvc必然做了统一的异常拦截。
Java中的异常在什么时候由JVM处理
大哥异常能处理就处理 ，能处理 就 转换成RuntimeExcepiton异常 供上层处理也可以让jvm处理。 简单来说,当在N层方法调用中,归根到底,最终都是由主类的主方法(即Main方法)去调用的,亦称之为入口方法,当产生的异常在所有方法中都未处理时,最终会交给JVM处理,处理结果就是终止程序运行,并抛出异常信息。一般在设计中，如果想该代码产生异常而方便查错时，会保留该异常不处理，或向上一层抛出该异常，其他情况都会Try Catch去处理。
实例
下面的例子中声明有两个元素的一个数组，当代码试图访问数组的第三个元素的时候就会抛出一个异常。
ExcepTest.java 文件代码：
// 文件名 : ExcepTest.java import java.io.*; public class ExcepTest{ public static void main(String args[]){ try{ int a[] = new int[2]; System.out.println("Access element three :" + a[3]); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("Exception thrown :" + e); } System.out.println("Out of the block"); } }
以上代码编译运行输出结果如下：
Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3 Out of the block
多重捕获块
一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获。
多重捕获块的语法如下所示：
try{ // 程序代码 }catch(异常类型1 异常的变量名1){ // 程序代码 }catch(异常类型2 异常的变量名2){ // 程序代码 }catch(异常类型2 异常的变量名2){ // 程序代码 }
上面的代码段包含了 3 个 catch块。
可以在 try 语句后面添加任意数量的 catch 块。
如果保护代码中发生异常，异常被抛给第一个 catch 块。
如果抛出异常的数据类型与 ExceptionType1 匹配，它在这里就会被捕获。
如果不匹配，它会被传递给第二个 catch 块。
如此，直到异常被捕获或者通过所有的 catch 块。
实例
该实例展示了怎么使用多重 try/catch。
try { file = new FileInputStream(fileName); x = (byte) file.read(); }catch(IOException i) { i.printStackTrace(); return -1; }catch(FileNotFoundException f) //Not valid! { f.printStackTrace(); return -1; }
throws/throw 关键字：
如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。
也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。
下面方法的声明抛出一个 RemoteException 异常：
import java.io.*; public class className { public void deposit(double amount) throws RemoteException { // Method implementation throw new RemoteException(); } //Remainder of class definition }
一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。
例如，下面的方法声明抛出 RemoteException 和 InsufficientFundsException：
import java.io.*; public class className { public void withdraw(double amount) throws RemoteException, InsufficientFundsException { // Method implementation } //Remainder of class definition }
finally关键字
finally 关键字用来创建在 try 代码块后面执行的代码块。
无论是否发生异常，finally 代码块中的代码总会被执行。
在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
finally 代码块出现在 catch 代码块最后，语法如下：
try{ // 程序代码 }catch(异常类型1 异常的变量名1){ // 程序代码 }catch(异常类型2 异常的变量名2){ // 程序代码 }finally{ // 程序代码 }
声明自定义异常
在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。
- 所有异常都必须是 Throwable 的子类。
- 如果希望写一个检查性异常类，则需要继承 Exception 类。
- 如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。
可以像下面这样定义自己的异常类：
class MyException extends Exception{ }
只继承Exception 类来创建的异常类是检查性异常类。
下面的 InsufficientFundsException 类是用户定义的异常类，它继承自 Exception。
一个异常类和其它任何类一样，包含有变量和方法。
实例
以下实例是一个银行账户的模拟，通过银行卡的号码完成识别，可以进行存钱和取钱的操作。
InsufficientFundsException.java 文件代码：
// 文件名InsufficientFundsException.java import java.io.*; //自定义异常类，继承Exception类 public class InsufficientFundsException extends Exception { //此处的amount用来储存当出现异常（取出钱多于余额时）所缺乏的钱 private double amount; public InsufficientFundsException(double amount) { this.amount = amount; } public double getAmount() { return amount; } }
为了展示如何使用我们自定义的异常类，
在下面的 CheckingAccount 类中包含一个 withdraw() 方法抛出一个 InsufficientFundsException 异常。
CheckingAccount.java 文件代码：
// 文件名称 CheckingAccount.java import java.io.*; //此类模拟银行账户 public class CheckingAccount { //balance为余额，number为卡号 private double balance; private int number; public CheckingAccount(int number) { this.number = number; } //方法：存钱 public void deposit(double amount) { balance += amount; } //方法：取钱 public void withdraw(double amount) throws InsufficientFundsException { if(amount <= balance) { balance -= amount; } else { double needs = amount - balance; throw new InsufficientFundsException(needs); } } //方法：返回余额 public double getBalance() { return balance; } //方法：返回卡号 public int getNumber() { return number; } }
下面的 BankDemo 程序示范了如何调用 CheckingAccount 类的 deposit() 和 withdraw() 方法。
BankDemo.java 文件代码：
//文件名称 BankDemo.java public class BankDemo { public static void main(String [] args) { CheckingAccount c = new CheckingAccount(101); System.out.println("Depositing $500..."); c.deposit(500.00); try { System.out.println("\nWithdrawing $100..."); c.withdraw(100.00); System.out.println("\nWithdrawing $600..."); c.withdraw(600.00); }catch(InsufficientFundsException e) { System.out.println("Sorry, but you are short $" + e.getAmount()); e.printStackTrace(); } } }
编译上面三个文件，并运行程序 BankDemo，得到结果如下所示：
Depositing $500...
Withdrawing $100...
Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException
at CheckingAccount.withdraw(CheckingAccount.java:25)
at BankDemo.main(BankDemo.java:13)
原文地址：https://www.cnblogs.com/panxuejun/p/10080364.html