一、异常的概念

  异常指的是运行期出现的错误,也就是当程序开始执行以后执行期出现的错误。出现错误时观察错误的名字和行号最为重要。

  

  1. 1 package cn.javastudy.summary;
  2. 2
  3. 3 public class TestEx{
  4. 4
  5. 5 public static void main(String args[]){
  6. 6 int arr[]={1,2,3};
  7. 7 System.out.println(arr[2]);
  8. 8 /**
  9. 9 * 这里使用try……catch来捕获除以0产生的异常,其基本格式是:
  10. 10 * try{
  11. 11 statements;//可能产生异常的语句
  12. 12 ……
  13. 13 }
  14. 14 catch(Throwable-subclass e){//异常参数e
  15. 15 statements;//异常处理程序
  16. 16 ……
  17. 17 }
  18. 18 */
  19. 19 try{
  20. 20 System.out.println(arr[2]/0);
  21. 21 }catch(ArithmeticException ae){//这里是这个异常参数的类型声明,即声明这个异常是属于哪种类型的异常
  22. 22 System.out.println("系统正在维护中,请稍后!");
  23. 23 /**
  24. 24 * 这里使用printStackTrace()方法把这个错误的堆栈信息打印出来。
  25. 25 * 所谓的“错误堆栈信息”指的是这个错误有可能是上一个错误引起的,
  26. 26 * 而上一个错误又有可能是由另外一个错误引起的。到底是由哪个错误引起的,
  27. 27 * 把所有的错误信息全都打印出来就知道了。这种信息往往能给我们程序员调试错误的提示。
  28. 28 * 这些信息很有用,因此我们往往使用这个方法把错误信息打印出来。
  29. 29 * 默认打印错误提示信息采用的也是使用这种方法打印出来的
  30. 30 */
  31. 31 ae.printStackTrace();
  32. 32 }
  33. 33 }
  34. 34 }

代码运行结果:

  

小结:

  异常是运行期间出现的错误,运行期间出现错误以后JAVA处理这种错误的方式是首先会找相应的catch代码,看看有没有使用catch去捕获异常,如果有catch存在,那么JAVA就会自动跳到catch那里去处理异常,如果没有catch,那么JAVA将会把这个错误抛出去,然后将相关的错误信息打印出来。想用catch捕获异常时必须要写try,没有try就不能用catch,try里面写的是有可能产生异常的语句,catch里面写的是当try里面的语句运行时出现了异常的处理方式。

  方法声明的时候可以指明这个方法有可能会抛出的异常类型,使用throw抛出异常,声明方法后面有throws声明的可能出现的异常一定要去捕获。

  

二、异常的分类

  

三、异常的捕获和处理

  Java异常处理的五个关键字:try、catch、finally、throw、throws

  

  

  

  

  当捕获到异常以后一定要做出处理,哪怕是把这个异常的错误信息打印出来,这是一种良好的编程习惯。如果不处理,那就是把这个错误悄悄地隐藏起来了,可是这个错误依然是存在的,只不过看不到了而已。这是一种非常危险的编程习惯,绝对不能这样做,捕获到异常就一定要做出处理,实在处理不了就把异常抛出去,让别的方法去处理。总之就是不能捕获到异常之后却又不做出相应的处理,这是一种非常不好的编程习惯。

  任何方法往外抛能处理的异常的时候都有一种简单的写法:“throws Exception”,因为Exception类是所有能处理的异常类的根基类,因此抛出Exception类就会抛出所有能够被处理的异常类里了。使用“throws Exception”抛出所有能被处理的异常之后,这些被抛出来的异常就是交给JAVA运行时系统处理了,而处理的方法是把这些异常的相关错误堆栈信息全部打印出来。除了在做测试以外,在实际当中编程的时候,在main方法里抛Exception是一个非常不好的编程习惯,应该使用try……catch去捕获异常并处理掉捕获后的异常。不能直接在main方法里把Exception抛出去交给JAVA运行时系统出力就完事了,这是一种不负责任的表现。如果想把程序写得特别健壮,使用try……catch去捕获异常并处理掉捕获后的异常是必不可少的做法。

四、try...cath...finally语句

  4.1. try语句

  

  4.2. catch语句

  

  我们一般使用printStackTrace()这个方法来打印异常的信息,使用这个方法打印出来的是所有出错的信息,包括了使用getMessage()方法打印出来的信息。使用这个方法之前要new一个错误对象出来才能调用它。因为它是专属于某个错误对象里面的方法。

  4.3. finally语句

  

  4.4.异常简单测试

  1. 1 package cn.javastudy.summary;
  2. 2
  3. 3 import java.io.FileInputStream;
  4. 4 import java.io.FileNotFoundException;
  5. 5 import java.io.IOException;
  6. 6
  7. 7 public class TestException {
  8. 8
  9. 9 /**
  10. 10 * 任何方法往外抛能处理的异常的时候都有一种简单的写法:“throws Exception”,
  11. 11 * 因为Exception类是所有能处理的异常类的根基类,因此抛出Exception类就会抛出所有能够被处理的异常类里了。
  12. 12 * 使用“throws Exception”抛出所有能被处理的异常之后,这些被抛出来的异常就是交给JAVA运行时系统处理了,
  13. 13 * 而处理的方法是把这些异常的相关错误堆栈信息全部打印出来。
  14. 14 * @throws Exception
  15. 15 */
  16. 16 void fn() throws Exception {
  17. 17
  18. 18 }
  19. 19
  20. 20 /**
  21. 21 * 在知道异常的类型以后,方法声明时使用throws把异常往外抛
  22. 22 * @param i
  23. 23 * @throws ArithmeticException
  24. 24 */
  25. 25 void m1(int i) throws ArithmeticException {
  26. 26
  27. 27 }
  28. 28
  29. 29 void m2(int i) {
  30. 30 if (i == 0) {
  31. 31 //这种做法就是手动抛出异常,使用“throw+new出来的异常对象”就可以把这个异常对象抛出去了。
  32. 32 //这里是new了一个异常对象,在构建这个对象的时候还可以指定他相关的信息,如这里指明了异常信息“i不能等于0”
  33. 33 //这个对象抛出去的时候使用getMessage()方法拿到的就是“i不能等于0”这种信息。
  34. 34 throw new ArithmeticException("i不能等于0");
  35. 35 }
  36. 36 }
  37. 37
  38. 38 /**
  39. 39 * 正常情况下如果这里不写try……catch语句那么程序编译时一定会报错,
  40. 40 * 因为这里有可能会产生两个个必须要处理的异常:FileNotFoundException和IOException。
  41. 41 * 但由于在声明方法f()时已经使用throws把可能产生的这两个异常抛出了,
  42. 42 * 所以这里可以不写try……catch语句去处理可能会产生的异常。
  43. 43 * f()方法把抛出的异常交给下一个要调用它的方法去处理
  44. 44 * @throws FileNotFoundException
  45. 45 * @throws IOException
  46. 46 */
  47. 47 void f() throws FileNotFoundException, IOException {
  48. 48 //这里有可能会产生FileNotFoundException异常
  49. 49 FileInputStream fis = new FileInputStream("MyFile.txt");
  50. 50 //这里有可能会产生IOException异常
  51. 51 int b = fis.read();
  52. 52 while (b != -1) {
  53. 53 System.out.println((char)b);
  54. 54 b = fis.read();
  55. 55 }
  56. 56 }
  57. 57
  58. 58 /**
  59. 59 * 在f2()方法里面调用f()方法时必须要处理f()方法抛出来的异常,
  60. 60 * 当然,如果f2()方法也没有办法处理f()方法抛出来的异常,那么f2()方法也可以使用throws把异常抛出,
  61. 61 * 交给下一个调用了f2()的方法去处理f()方法抛出来的异常。
  62. 62 * 这里f2()调用f()方法时,选择不处理f()方法中可能抛出的异常,将异常继续抛出
  63. 63 * @throws Exception
  64. 64 */
  65. 65 void f2() throws Exception {
  66. 66 f();
  67. 67 }
  68. 68
  69. 69 /**
  70. 70 * f3方法调用f方法捕获f()方法抛出的2个异常并进行处理
  71. 71 */
  72. 72 void f3() {
  73. 73 try {
  74. 74 f();
  75. 75 } catch (FileNotFoundException e) {
  76. 76 System.out.println(e.getMessage());//处理的方法是把错误信息打印出来
  77. 77 } catch (IOException e) {
  78. 78 e.printStackTrace();//处理的方法是使用printStackTrace()方法把错误的堆栈信息全部打印出来。
  79. 79 }
  80. 80 }
  81. 81
  82. 82 public static void main(String[] args) {
  83. 83 FileInputStream fis = null;
  84. 84 try {
  85. 85 fis = new FileInputStream("MyFile.txt");
  86. 86 int b = fis.read();//这个有可能会抛出IOException异常
  87. 87 while (b != -1) {
  88. 88 System.out.println((char)b);
  89. 89 b = fis.read();
  90. 90 }
  91. 91 } catch (FileNotFoundException e) {
  92. 92 //使用catch捕获FileNotFoundException类异常的异常对象e。并让异常对象e自己调用printStackTrace方法打印出全部的错误信息
  93. 93 e.printStackTrace();
  94. 94 } catch (IOException e) {
  95. 95 //再次使用catch捕获IOException类的异常对象e,并让异常对象e自己调用getMessage()方法将错误信息打印出来。
  96. 96 System.out.println(e.getMessage());;
  97. 97 }finally{
  98. 98 try {
  99. 99 /**
  100. 100 * 前面已经把一个文件打开了,不管打开这个文件时有没有错误发生,即有没有产生异常,最后都一定要把这个文件关闭掉,
  101. 101 * 因此使用了finally语句,在finally语句里面不管前面这个文件打开时是否产生异常,在finally这里执行in.close()都能把这个文件关闭掉,
  102. 102 * 关闭文件也有可能会产生异常,因此在finally里面也使用了try……catch语句去捕获有可能产生的异常。
  103. 103 */
  104. 104 fis.close();
  105. 105 } catch (IOException e) {
  106. 106 e.printStackTrace();
  107. 107 }
  108. 108 }
  109. 109 }
  110. 110 }

五、声明并抛出异常

六、使用自定义异常

  

6.1. 自定义异常

  1. 1 package cn.javastudy.summary;
  2. 2
  3. 3 /**
  4. 4 * 自定义的一个异常类MyException,且是从Exception类继承而来
  5. 5 */
  6. 6 public class MyException extends Exception {
  7. 7
  8. 8 private int id;
  9. 9
  10. 10 /**
  11. 11 * 自定义异常类的构造方法
  12. 12 * @param message
  13. 13 * @param id
  14. 14 */
  15. 15 public MyException(String message,int id) {
  16. 16 super(message);//调用父类Exception的构造方法
  17. 17 this.id = id;
  18. 18 }
  19. 19
  20. 20 /**
  21. 21 * 获取异常的代码
  22. 22 * @return
  23. 23 */
  24. 24 public int getId() {
  25. 25 return id;
  26. 26 }
  27. 27
  28. 28 }

6.2.自定义异常测试

  1. 1 package cn.javastudy.summary;
  2. 2
  3. 3 import java.text.MessageFormat;
  4. 4
  5. 5 public class TestMyException {
  6. 6
  7. 7 //throws MyException,抛出我们自定义的MyException类的异常。
  8. 8 public void regist(int num) throws MyException {
  9. 9 if (num < 0) {
  10. 10 //使用throw手动抛出一个MyException类的异常对象。
  11. 11 throw new MyException("人数为负值,不合理", 1);
  12. 12 }
  13. 13 /**
  14. 14 * 注意:当我们抛出了异常之后,
  15. 15 * System.out.println(MessageFormat.format("登记人数:{0}",num));是不会被执行的。
  16. 16 * 抛出异常之后整个方法的调用就结束了。
  17. 17 */
  18. 18 System.out.println(MessageFormat.format("登记人数:{0}",num));
  19. 19 }
  20. 20
  21. 21 public void manage() {
  22. 22 try {
  23. 23 regist(-100);
  24. 24 } catch (MyException e) {
  25. 25 System.out.println("登记失败,错误码:"+e.getId());
  26. 26 e.printStackTrace();
  27. 27 }
  28. 28 System.out.println("操作结束");
  29. 29 }
  30. 30
  31. 31
  32. 32 public static void main(String[] args) {
  33. 33 TestMyException t = new TestMyException();
  34. 34 t.manage();
  35. 35 }
  36. 36
  37. 37 }

测试结果:

  

七、异常处理总结

  

  养成良好的编程习惯,不要把错误给吞噬掉(即捕获到异常以后又不做出相应处理的做法,这种做法相当于是把错误隐藏起来了,可实际上错误依然还是存在的), 也不要轻易地往外抛错误,能处理的一定要处理,不能处理的一定要往外抛。往外抛的方法有两种,一种是在知道异常的类型以后,方法声明时使用throws把 异常往外抛,另一种是手动往外抛,使用“throw+异常对象”你相当于是把这个异常对象抛出去了,然后在方法的声明写上要抛的那种异常。

Java基础学习总结(22)——异常处理的更多相关文章

  1. 转载-java基础学习汇总

    共2页: 1 2 下一页  Java制作证书的工具keytool用法总结 孤傲苍狼 2014-06-24 11:03 阅读:25751 评论:3     Java基础学习总结——Java对象的序列化和 ...

  2. 尚学堂JAVA基础学习笔记

    目录 尚学堂JAVA基础学习笔记 写在前面 第1章 JAVA入门 第2章 数据类型和运算符 第3章 控制语句 第4章 Java面向对象基础 1. 面向对象基础 2. 面向对象的内存分析 3. 构造方法 ...

  3. Java基础学习笔记总结

    Java基础学习笔记一 Java介绍 Java基础学习笔记二 Java基础语法之变量.数据类型 Java基础学习笔记三 Java基础语法之流程控制语句.循环 Java基础学习笔记四 Java基础语法之 ...

  4. JAVA基础学习-集合三-Map、HashMap,TreeMap与常用API

    森林森 一份耕耘,一份收获 博客园 首页 新随笔 联系 管理 订阅 随笔- 397  文章- 0  评论- 78  JAVA基础学习day16--集合三-Map.HashMap,TreeMap与常用A ...

  5. [转帖]java基础学习总结——多态(动态绑定)

    https://www.cnblogs.com/xdp-gacl/p/3644035.html 多态的概念 java基础学习总结——多态(动态绑定) 一.面向对象最核心的机制——动态绑定,也叫多态

  6. java基础学习笔记五(抽象类)

    java基础学习总结——抽象类 抽象类介绍

  7. Java基础学习-- 继承 的简单总结

    代码参考:Java基础学习小记--多态 为什么要引入继承? 还是做一个媒体库,里面可以放CD,可以放DVD.如果把CD和DVD做成两个没有联系的类的话,那么在管理这个媒体库的时候,要单独做一个添加CD ...

  8. Java基础学习中一些词语和语句的使用

    在Java基础学习中,我们刚接触Java会遇到一些词和语句的使用不清的情况,不能很清楚的理解它的运行效果会是怎么样的,如:break,continue在程序中运行效果及跳转位置, 1.先来看看brea ...

  9. java基础学习总结——开篇

    java是我学习的第一门编程语言,当初学习java基础的时候下了不少功夫,趁着这段时间找工作之际,好好整理一下以前学习java基础时记录的笔记,当作是对java基础学习的一个总结吧,将每一个java的 ...

  10. Java基础学习笔记(一)

    Java基础学习笔记(一) Hello World 基础代码学习 代码编写基础结构 class :类,一个类即一个java代码,形成一个class文件,写于每个代码的前端(注意无大写字母) XxxYy ...

随机推荐

  1. BAT 解密(四):配置中心、服务中心、异步技术细节

    在系列文章的第二篇文章< BAT解密(二):聊聊业务如何驱动技术发展 >中我们深入分析了互联网业务发展的一个特点:复杂性越来越高.复杂性增加的典型现象就是系统越来越多,当系统的数量增加到一 ...

  2. Generating SSH Keys for github

    由于最近电脑重装了Windows 8.1, 想用github维护一些代码.故不得不重新生成一下ssh key. 按https://help.github.com/articles/generating ...

  3. OpenGL编程(七)3D模型的深度(z轴)检测

    下图是我们要修改后的效果图: 一.深度检测 1.模型Z轴显示有问题: 上一次试验中,如果认真留意,会发现一个问题.当控制锥体在左右或上下旋转时,你会发现锥体看起来是在+-180度之间来回摆动,而不是3 ...

  4. eclipse用tomcat发布网站的目录

    用eclipse添加的tomcat发布网站时,在tomcat安装目录中的webapps时找不到发布的网站.这是由于eclipse的默认配置,把项目发布到别的文件夹中了.如果想发布到webapps里面, ...

  5. POJ 1664 放苹果【DFS】

    题意:给出n个苹果,m个盘子,问有多少种不同的苹果放置方法 可以把它抽象为把一个数n,拆分成a1,a2,a3,---,am,使得它们的和为n, 话说这一题是学习的ppt里面的,它的思路就是搜索 搜索条 ...

  6. 找出 alter system kill session ‘sid,serial#’ kill 掉的数据库会话对应进程

    当我们使用alter system kill session ‘sid,serial#’ 在数据库中kill掉某个会话的时候,如果你观察仔细会发现v$session.paddr发生了改变,从而是的不能 ...

  7. win10 无法访问XP 共享目录原因

    win10 无法访问XP 共享目录原因     *现象:  在地址栏中输入\\192.168.100.5 (XP文件服务器),出现:.....找不到网络路径, 此连接尚未还原.             ...

  8. php xml 的基本操作类

    class xmlMessage{ protected $doc; protected $rootKey; public function __construct() { $this->doc ...

  9. CF1015F Bracket Substring (KMP+DP)

    题目大意:给你一个长度为$n$的括号序列$T$,要求你构造一个长度为$2n$的括号序列$S$,保证这个括号序列在插入数字后一定是正确的,并且$T$是$S$的一个子串 还以为是什么纯粹的数学构造题,一通 ...

  10. HTTP 文件共享服务器工具 - chfs

    CuteHttpFileServer/chfs是一个免费的.HTTP协议的文件共享服务器,使用浏览器可以快速访问.它具有以下特点: 单个文件,整个软件只有一个可执行程序,无配置文件等其他文件 跨平台运 ...