阅读目录
JAVA异常与异常处理详解
一、异常简介
什么是异常？
异常就是有异于常态，和正常情况不一样，有错误出错。在java中，阻止当前方法或作用域的情况，称之为异常。
java中异常的体系是怎么样的呢？
1.Java中的所有不正常类都继承于Throwable类。Throwable主要包括两个大类，一个是Error类，另一个是Exception类；
2.其中Error类中包括虚拟机错误和线程死锁，一旦Error出现了，程序就彻底的挂了，被称为程序终结者；
3.Exception类，也就是通常所说的“异常”。主要指编码、环境、用户操作输入出现问题，Exception主要包括两大类，非检查异常（RuntimeException）和检查异常（其他的一些异常）
4.RuntimeException异常主要包括以下四种异常（其实还有很多其他异常，这里不一一列出）：空指针异常、数组下标越界异常、类型转换异常、算术异常。RuntimeException异常会由java虚拟机自动抛出并自动捕获（就算我们没写异常捕获语句运行时也会抛出错误！！），此类异常的出现绝大数情况是代码本身有问题应该从逻辑上去解决并改进代码。
5.检查异常，引起该异常的原因多种多样，比如说文件不存在、或者是连接错误等等。跟它的“兄弟”RuntimeException运行异常不同，该异常我们必须手动在代码里添加捕获语句来处理该异常，这也是我们学习java异常语句中主要处理的异常对象。
二、try-catch-finally语句
（1）try块：负责捕获异常，一旦try中发现异常，程序的控制权将被移交给catch块中的异常处理程序。
【try语句块不可以独立存在，必须与 catch 或者 finally 块同存】
（2）catch块：如何处理？比如发出警告：提示、检查配置、网络连接，记录错误等。执行完catch块之后程序跳出catch块，继续执行后面的代码。
【编写catch块的注意事项：多个catch块处理的异常类，要按照先catch子类后catch父类的处理方式，因为会【就近处理】异常（由上自下）。】
（3）finally：最终执行的代码，用于关闭和释放资源。
=======================================================================
语法格式如下：
try{//一些会抛出的异常}catch（Exception e）{//第一个catch//处理该异常的代码块}catch（Exception e）{//第二个catch，可以有多个catch//处理该异常的代码块}finally{//最终要执行的代码}
当异常出现时，程序将终止执行，交由异常处理程序（抛出提醒或记录日志等），异常代码块外代码正常执行。 try会抛出很多种类型的异常，由多个catch块捕获多钟错误。
多重异常处理代码块顺序问题：先子类再父类（顺序不对编译器会提醒错误），finally语句块处理最终将要执行的代码。
=======================================================================
接下来，我们用实例来巩固try-catch语句吧~
先看例子：
1 package com.hysum.test; 2 3 public class TryCatchTest { 4 /** 5 * divider:除数 6 * result:结果 7 * try-catch捕获while循环 8 * 每次循环，divider减一，result=result+100/divider 9 * 如果：捕获异常，打印输出“异常抛出了”，返回-110 * 否则：返回result11 * @return12 */13 public int test1(){14 int divider=10;15 int result=100;16 try{17 while(divider>-1){18 divider--;19 result=result+100/divider;20 }21 return result;22 }catch(Exception e){23 e.printStackTrace();24 System.out.println("异常抛出了！！");25 return -1;26 }27 }28 public static void main(String[] args) {29 // TODO Auto-generated method stub30 TryCatchTest t1=new TryCatchTest();31 System.out.println("test1方法执行完毕！result的值为："+t1.test1());32 }33 34 }
运行结果：
结果分析：结果中的红色字抛出的异常信息是由e.printStackTrace()来输出的，它说明了这里我们抛出的异常类型是算数异常，后面还跟着原因：by zero（由0造成的算数异常），下面两行at表明了造成此异常的代码具体位置。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
在上面例子中再加上一个test2()方法来测试finally语句的执行状况：
1 /** 2 * divider:除数 3 * result:结果 4 * try-catch捕获while循环 5 * 每次循环，divider减一，result=result+100/divider 6 * 如果：捕获异常，打印输出“异常抛出了”，返回result=999 7 * 否则：返回result 8 * finally：打印输出“这是finally，哈哈哈！！”同时打印输出result 9 * @return10 */11 public int test2(){12 int divider=10;13 int result=100;14 try{15 while(divider>-1){16 divider--;17 result=result+100/divider;18 }19 return result;20 }catch(Exception e){21 e.printStackTrace();22 System.out.println("异常抛出了！！");23 return result=999;24 }finally{25 System.out.println("这是finally，哈哈哈！！");26 System.out.println("result的值为："+result);27 }28 29 }30 31 32 33 public static void main(String[] args) {34 // TODO Auto-generated method stub35 TryCatchTest t1=new TryCatchTest();36 //System.out.println("test1方法执行完毕！result的值为："+t1.test1());37 t1.test2();38 System.out.println("test2方法执行完毕！");39 }
运行结果：
结果分析：我们可以从结果看出，finally语句块是在try块和catch块语句执行之后最后执行的。finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，仍然是之前保存的值），所以函数返回值是在finally执行前确定的；
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
这里有个有趣的问题，如果把上述中的test2方法中的finally语句块中加上return，编译器就会提示警告：finally block does not complete normally
1 public int test2(){ 2 int divider=10; 3 int result=100; 4 try{ 5 while(divider>-1){ 6 divider--; 7 result=result+100/divider; 8 } 9 return result;10 }catch(Exception e){11 e.printStackTrace();12 System.out.println("异常抛出了！！");13 return result=999;14 }finally{15 System.out.println("这是finally，哈哈哈！！");16 System.out.println("result的值为："+result);17 return result;//编译器警告18 }19 20 }
分析问题: finally块中的return语句可能会覆盖try块、catch块中的return语句;如果finally块中包含了return语句，即使前面的catch块重新抛出了异常，则调用该方法的语句也不会获得catch块重新抛出的异常，而是会得到finally块的返回值，并且不会捕获异常。
解决问题：面对上述情况，其实更合理的做法是，既不在try block内部中使用return语句，也不在finally内部使用 return语句，而应该在 finally 语句之后使用return来表示函数的结束和返回。如：
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
总结：
1、不管有木有出现异常或者try和catch中有返回值return，finally块中代码都会执行；
2、finally中最好不要包含return，否则程序会提前退出，返回会覆盖try或catch中保存的返回值。
3. e.printStackTrace()可以输出异常信息。
4. return值为-1为抛出异常的习惯写法。
5. 如果方法中try,catch,finally中没有返回语句，则会调用这三个语句块之外的return结果。
6. finally 在try中的return之后 在返回主调函数之前执行。
三、throw和throws关键字
java中的异常抛出通常使用throw和throws关键字来实现。
throw ----将产生的异常抛出，是抛出异常的一个动作。
一般会用于程序出现某种逻辑时程序员主动抛出某种特定类型的异常。如：
语法：throw (异常对象)，如：
1 public static void main(String[] args) {
2 String s = "abc";
3 if(s.equals("abc")) {
4 throw new NumberFormatException();
5 } else {
6 System.out.println(s);
7 }
8 //function(); 9 }
运行结果：
Exception in thread "main" java.lang.NumberFormatException at test.ExceptionTest.main(ExceptionTest.java:67)
throws----声明将要抛出何种类型的异常（声明）。
语法格式：
1 public void 方法名（参数列表）2 throws 异常列表{3 //调用会抛出异常的方法或者：4 throw new Exception（）；5 }当某个方法可能会抛出某种异常时用于throws 声明可能抛出的异常，然后交给上层调用它的方法程序处理。如：
1 public static void function() throws NumberFormatException{
2 String s = "abc";
3 System.out.println(Double.parseDouble(s));
4 }
5 6 public static void main(String[] args) {
7 try {
8 function();
9 } catch (NumberFormatException e) {
10 System.err.println("非数据类型不能转换。");
11 //e.printStackTrace(); 12 }
13 }
throw与throws的比较
1、throws出现在方法函数头；而throw出现在函数体。
2、throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。
3、两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。
来看个例子：
throws e1,e2,e3只是告诉程序这个方法可能会抛出这些异常，方法的调用者可能要处理这些异常，而这些异常e1，e2，e3可能是该函数体产生的。
throw则是明确了这个地方要抛出这个异常。如：
1 void doA(int a) throws (Exception1,Exception2,Exception3){ 2 try{ 3 ...... 4 5 }catch(Exception1 e){ 6 throw e; 7 }catch(Exception2 e){ 8 System.out.println("出错了！"); 9 }10 if(a!=b)11 throw new Exception3("自定义异常");12 }
分析:
1.代码块中可能会产生3个异常，(Exception1,Exception2,Exception3)。
2.如果产生Exception1异常，则捕获之后再抛出，由该方法的调用者去处理。
3.如果产生Exception2异常，则该方法自己处理了（即System.out.println("出错了！");）。所以该方法就不会再向外抛出Exception2异常了，void doA() throws Exception1,Exception3 里面的Exception2也就不用写了。因为已经用try-catch语句捕获并处理了。
4.Exception3异常是该方法的某段逻辑出错，程序员自己做了处理，在该段逻辑错误的情况下抛出异常Exception3，则该方法的调用者也要处理此异常。这里用到了自定义异常，该异常下面会由解释。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
使用throw和throws关键字需要注意以下几点：
1.throws的异常列表可以是抛出一条异常，也可以是抛出多条异常，每个类型的异常中间用逗号隔开
2.方法体中调用会抛出异常的方法或者是先抛出一个异常：用throw new Exception（） throw写在方法体里，表示“抛出异常”这个动作。
3.如果某个方法调用了抛出异常的方法，那么必须添加try catch语句去尝试捕获这种异常， 或者添加声明，将异常抛出给更上一层的调用者进行处理
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
自定义异常
为什么要使用自定义异常，有什么好处？
1.我们在工作的时候，项目是分模块或者分功能开发的 ,基本不会你一个人开发一整个项目，使用自定义异常类就统一了对外异常展示的方式。
2.有时候我们遇到某些校验或者问题时，需要直接结束掉当前的请求，这时便可以通过抛出自定义异常来结束，如果你项目中使用了SpringMVC比较新的版本的话有控制器增强，可以通过@ControllerAdvice注解写一个控制器增强类来拦截自定义的异常并响应给前端相应的信息。
3.自定义异常可以在我们项目中某些特殊的业务逻辑时抛出异常，比如"中性".equals(sex)，性别等于中性时我们要抛出异常，而Java是不会有这种异常的。系统中有些错误是符合Java语法的，但不符合我们项目的业务逻辑。
4.使用自定义异常继承相关的异常来抛出处理后的异常信息可以隐藏底层的异常，这样更安全，异常信息也更加的直观。自定义异常可以抛出我们自己想要抛出的信息，可以通过抛出的信息区分异常发生的位置，根据异常名我们就可以知道哪里有异常，根据异常提示信息进行程序修改。比如空指针异常NullPointException，我们可以抛出信息为“xxx为空”定位异常位置，而不用输出堆栈信息。
说完了为什么要使用自定义异常，有什么好处，我们再来看看自定义异常的毛病：
毋庸置疑，我们不可能期待JVM（Java虚拟机）自动抛出一个自定义异常，也不能够期待JVM会自动处理一个自定义异常。发现异常、抛出异常以及处理异常的工作必须靠编程人员在代码中利用异常处理机制自己完成。这样就相应的增加了一些开发成本和工作量，所以项目没必要的话，也不一定非得要用上自定义异常，要能够自己去权衡。
最后，我们来看看怎么使用自定义异常：
在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。
所有异常都必须是 Throwable 的子类。
如果希望写一个检查性异常类，则需要继承 Exception 类。
如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。
可以像下面这样定义自己的异常类：
class MyException extends Exception{ }
我们来看一个实例：
1 package com.hysum.test; 2 3 public class MyException extends Exception { 4 /** 5 * 错误编码 6 */ 7 private String errorCode; 8 9 10 public MyException(){}11 12 /**13 * 构造一个基本异常.14 *15 * @param message16 * 信息描述17 */18 public MyException(String message)19 {20 super(message);21 }22 23 24 25 public String getErrorCode() {26 return errorCode;27 }28 29 public void setErrorCode(String errorCode) {30 this.errorCode = errorCode;31 }32 33 34 }
使用自定义异常抛出异常信息：
1 package com.hysum.test; 2 3 public class Main { 4 5 public static void main(String[] args) { 6 // TODO Auto-generated method stub 7 String[] sexs = {"男性","女性","中性"}; 8 for(int i = 0; i < sexs.length; i++){ 9 if("中性".equals(sexs[i])){10 try {11作者： 云开的立夏
出处： http://www.cnblogs.com/hysum/>
关于作者：本人目前还在上学，小白一枚，希望能把学过的知识与大家分享，请多多赐教！
版权声明：本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出 原文链接
大家写文都不容易，请尊重劳动成果~这里谢谢大家啦(*/ω＼*) 如有问题， 可邮件（hysum626@162.com）咨询.
http://www.cnblogs.com/hysum/p/7112011.html
延伸阅读
- 向着Java前进 2023-04-15 14:27:04.883
- 2021年Java程序员的就业前景如何？ 2022-02-17 10:55:25.903
- 感谢万码，我认识到了java的魅力 2021-05-23 15:03:29.353
- 今天我成为了Java工程师 2021-05-23 15:02:21.417
- 打牢基础才能更有作为 2021-05-19 11:04:08.263
- 我的JAVA生涯 ——解*泉 2020-01-15 14:15:05.59
- 以java为剑，仗剑走江湖—尚*权 2019-12-22 17:24:42.217
- 开启我的java征途——郑*亮 2019-11-06 17:05:39.77
- 我想这就是Java工程师的工作——刘*聪 2019-07-05 10:03:54.53
- 打牢基础，提高效率——陈*宁 2018-12-27 15:01:19.007
向着Java前进