java异常3-19

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java异常3-19相关的知识,希望对你有一定的参考价值。

在计算机程序运行的过程中,总是会出现各种各样的错误。

有一些错误是用户造成的,比如,希望用户输入一个​​int​​类型的年龄,但是用户的输入是​​abc​​:

// 假设用户输入了abc:
String s = "abc";
int n = Integer.parseInt(s); // NumberFormatException!

程序想要读写某个文件的内容,但是用户已经把它删除了:

// 用户删除了该文件:
String t = readFile("C:\\\\abc.txt"); // FileNotFoundException!

还有一些错误是随机出现,并且永远不可能避免的。比如:

  • 网络突然断了,连接不到远程服务器;
  • 内存耗尽,程序崩溃了;
  • 用户点“打印”,但根本没有打印机;
  • ……

所以,一个健壮的程序必须处理各种各样的错误。

所谓错误,就是程序调用某个函数的时候,如果失败了,就表示出错。

调用方如何获知调用失败的信息?有两种方法:

方法一:约定返回错误码。

例如,处理一个文件,如果返回​​0​​,表示成功,返回其他整数,表示约定的错误码:

int code = processFile("C:\\\\test.txt");
if (code == 0)
// ok:
else
// error:
switch (code)
case 1:
// file not found:
case 2:
// no read permission:
default:
// unknown error:

因为使用​​int​​类型的错误码,想要处理就非常麻烦。这种方式常见于底层C函数。

方法二:在语言层面上提供一个异常处理机制。

Java内置了一套异常处理机制,总是使用异常来表示错误。

异常是一种​​class​​,因此它本身带有类型信息。异常可以在任何地方抛出,但只需要在上层捕获,这样就和方法调用分离了:

try 
String s = processFile(“C:\\\\test.txt”);
// ok:
catch (FileNotFoundException e)
// file not found:
catch (SecurityException e)
// no read permission:
catch (IOException e)
// io error:
catch (Exception e)
// other error:

因为Java的异常是​​class​​,它的继承关系如下:

┌───────────┐
│ Object │
└───────────┘


┌───────────┐
│ Throwable │
└───────────┘

┌─────────┴─────────┐
│ │
┌───────────┐ ┌───────────┐
│ Error │ │ Exception │
└───────────┘ └───────────┘
▲ ▲
┌───────┘ ┌────┴──────────┐
│ │ │
┌─────────────────┐ ┌─────────────────┐┌───────────┐
│OutOfMemoryError │... │RuntimeException ││IOException│...
└─────────────────┘ └─────────────────┘└───────────┘

┌───────────┴─────────────┐
│ │
┌─────────────────────┐ ┌─────────────────────────┐
│NullPointerException │ │IllegalArgumentException │...
└─────────────────────┘ └─────────────────────────┘

从继承关系可知:​​Throwable​​是异常体系的根,它继承自​​Object​​。​​Throwable​​有两个体系:​​Error​​和​​Exception​​,​​Error​​表示严重的错误,程序对此一般无能为力,例如:

  • ​OutOfMemoryError​​:内存耗尽
  • ​NoClassDefFoundError​​:无法加载某个Class
  • ​StackOverflowError​​:栈溢出

而​​Exception​​则是运行时的错误,它可以被捕获并处理。

某些异常是应用程序逻辑处理的一部分,应该捕获并处理。例如:

  • ​NumberFormatException​​:数值类型的格式错误
  • ​FileNotFoundException​​:未找到文件
  • ​SocketException​​:读取网络失败

还有一些异常是程序逻辑编写不对造成的,应该修复程序本身。例如:

  • ​NullPointerException​​:对某个​​null​​的对象调用方法或字段
  • ​IndexOutOfBoundsException​​:数组索引越界

​Exception​​又分为两大类:

  1. ​RuntimeException​​以及它的子类;
  2. 非​​RuntimeException​​(包括​​IOException​​、​​ReflectiveOperationException​​等等)

Java规定:

  • 必须捕获的异常,包括Exception及其子类,但不包括RuntimeException及其子类,这种类型的异常称为Checked Exception。
  • 不需要捕获的异常,包括Error及其子类,RuntimeException及其子类。

 注意:编译器对RuntimeException及其子类不做强制捕获要求,不是指应用程序本身不应该捕获并处理RuntimeException。是否需要捕获,具体问题具体分析。

捕获异常

捕获异常使用​​try...catch​​语句,把可能发生异常的代码放到​​try ...​​中,然后使用​​catch​​捕获对应的​​Exception​​及其子类:

// try...catch
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

 Run

如果我们不捕获​​UnsupportedEncodingException​​,会出现编译失败的问题:

// try...catch
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

 Run

编译器会报错,错误信息类似:unreported exception UnsupportedEncodingException; must be caught or declared to be thrown,并且准确地指出需要捕获的语句是​​return s.getBytes("GBK");​​。意思是说,像​​UnsupportedEncodingException​​这样的Checked Exception,必须被捕获。

这是因为​​String.getBytes(String)​​方法定义是:

public byte[] getBytes(String charsetName) throws UnsupportedEncodingException 
...

在方法定义的时候,使用​​throws Xxx​​表示该方法可能抛出的异常类型。调用方在调用的时候,必须强制捕获这些异常,否则编译器会报错。

在​​toGBK()​​方法中,因为调用了​​String.getBytes(String)​​方法,就必须捕获​​UnsupportedEncodingException​​。我们也可以不捕获它,而是在方法定义处用throws表示​​toGBK()​​方法可能会抛出​​UnsupportedEncodingException​​,就可以让​​toGBK()​​方法通过编译器检查:

// try...catch
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

 Run

上述代码仍然会得到编译错误,但这一次,编译器提示的不是调用​​return s.getBytes("GBK");​​的问题,而是​​byte[] bs = toGBK("中文");​​。因为在​​main()​​方法中,调用​​toGBK()​​,没有捕获它声明的可能抛出的​​UnsupportedEncodingException​​。

修复方法是在​​main()​​方法中捕获异常并处理:

// try...catch
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

 Run

可见,只要是方法声明的Checked Exception,不在调用层捕获,也必须在更高的调用层捕获。所有未捕获的异常,最终也必须在​​main()​​方法中捕获,不会出现漏写​​try​​的情况。这是由编译器保证的。​​main()​​方法也是最后捕获​​Exception​​的机会。

如果是测试代码,上面的写法就略显麻烦。如果不想写任何​​try​​代码,可以直接把​​main()​​方法定义为​​throws Exception​​:

// try...catch
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

 Run

因为​​main()​​方法声明了可能抛出​​Exception​​,也就声明了可能抛出所有的​​Exception​​,因此在内部就无需捕获了。代价就是一旦发生异常,程序会立刻退出。

还有一些童鞋喜欢在​​toGBK()​​内部“消化”异常:

static byte[] toGBK(String s) 
try
return s.getBytes("GBK");
catch (UnsupportedEncodingException e)
// 什么也不干

return null;

这种捕获后不处理的方式是非常不好的,即使真的什么也做不了,也要先把异常记录下来:

static byte[] toGBK(String s) 
try
return s.getBytes("GBK");
catch (UnsupportedEncodingException e)
// 先记下来再说:
e.printStackTrace();

return null;

所有异常都可以调用​​printStackTrace()​​方法打印异常栈,这是一个简单有用的快速打印异常的方法。

小结

Java使用异常来表示错误,并通过​​try ... catch​​捕获异常;

Java的异常是​​class​​,并且从​​Throwable​​继承;

​Error​​是无需捕获的严重错误,​​Exception​​是应该捕获的可处理的错误;

​RuntimeException​​无需强制捕获,非​​RuntimeException​​(Checked Exception)需强制捕获,或者用​​throws​​声明;

不推荐捕获了异常但不进行任何处理。

Java - 异常处理

主要内容:
* Java 异常的概念。
* Java 异常的分类。
* 异常的捕获和处理。
 
 
Q:Java 是如何对异常进行处理的? 
A:Java 中定义了很多异常类,这些类对应了各种各样可能出现的异常事件,Java 程序的执行过程中如果出现异常事件,会生成一个异常对象并将其提交给 Java 运行时系统,该异常对象封装了该异常事件相应的信息,当 Java 运行时系统接收到异常对象时,会寻找能处理这一异常的代码并把当前异常对象交其处理。
 
 
异常(Exception) : 
* 指的是运行期出现在的错误,也就是当你程序开始执行以后,执行期出现的错误;而不是我们敲 javac 这时候出现的。
* 观察错误的名字和行号最重要!!!并且要敢于调试!!!记住一句话:程序是调出来的!!!
 
 
 
异常的概念: 
* Java 异常是 Java 提供的用于处理程序中错误的一种机制。
* 所谓错误是指在程序运行的过程中发生的一些异常事件(如:除 0 溢出、数组下标越界、所要读取的文件不存在)。
* 设计良好的程序应该在异常发生时提供处理这些错误的方法,使得程序不会因为异常的发生而阻断或产生不可预见的结果。
* Java 程序的执行过程中如出现异常事件,会生成一个异常对象,该异常对象封装了异常事件的信息并将被提交给 Java 运行时系统,这个过程称为抛出(throw)异常。
* 当 Java 运行时系统接收到异常对象时,会寻找能处理这一异常的代码并把当前异常对象交其处理,这一过程称为捕获(catch)异常。
 
 
 
 
异常的分类: 
* J2SDK 中定义了很多异常类,这些类对应了各种各样可能出现的异常事件。
* 异常的根基类是 Throwable。
* Throwable 它有已知的两个子类:Error、Exception。
* Exception 下有很多异常,其中有个特殊的异常叫:运行时异常(RuntimeException)
* 层级,如下简要图:
             Throwable
                 /      \
           Error      Exception
               /          /         \
         ...            ...      RuntimeException
                                            \
                                              ...
 
* 这些异常的区别: 
  ** Throwable:叫做可被抛出的,任何事件,只要你从 Throwable 这儿继承,你就可以用 throws 语句把它往外抛出。
  *** Error:叫做系统的错误,由 Java 虚拟机生成并抛出,包括动态链接失败、虚拟机错误等,程序对其不做处理;也就说 Java 虚拟机出错了,你的程序处理不了,你也不用处理。
  *** Exception:所有异常类的基类,其子类对应了各种各样可能出现的异常事件,一般需要用户显式的声明或捕获;也就说你程序能够处理的错误,可以捕获(catch)它。
   **** RuntimeException:一类特殊的异常,如除以 0 、数组下标越界等,其产生比较频繁,处理麻烦,如果显式的声明或捕获将会对程序可读性和运行效率影响很大;因此由系统自动检测并将它们交给缺省的异常处理程序(用户可不必对其处理);也就说是经常出的一种错误,这种错误你可以捕获它,也可以不捕获它(我们通常不捕获),不捕获照样能运行,只不过运行时出错而已,因为出的太频繁了,你老捕获它程序会累死去,打个比喻,例:你开车在路上,每看到一个小石子你就下车去捡开,那你不累死去,所以不如直接压过去就得了!
   **** 普通的 Exception:叫做必须捕获(catch)的 Exception, 要求你必须得捕获它程序才能往前走,凡是看见方法后面写了 throws 的,OK,这一类的异常你必须得捕获或声明抛出!
  *** 打个比喻来说明 Error 与 Exception 的区别,例:你开车在山路上走,你车子爆胎了,这时你可以停下来修理(换胎),这个叫 Exception ,因为你能处理它,那么如果是山塌陷了,你能处理吗?你不能,这时就叫 Error,你处理不了。
 
 
 
异常的捕获和处理: 
* Java 的例外处理机制使得例外事件沿着被调用的顺序往前寻找,直到找到符合该例外种类的例外处理程序。
* try 语句
  ** try {...} 语句指定了一段代码,该段代码就是一次捕获并处理例外的范围。
  ** 在执行过程中,该段代码可能会产生并抛出一种或几种类型的异常对象,它后面的 catch 语句要分别对这些异常做相应的处理。
  ** 如果没有例外产生,所有的 catch 代码段都被略过不执行。
* catch 语句
  ** 在 catch 语句块中是对异常进行处理的代码,每个 try 语句块可以伴随一个或多个 catch 语句,用于处理可能产生的不同类型的异常对象。
  ** 在 catch 中声明的异常对象(catch(SomeException e))封装了异常事件发生的信息,在 catch 语句块中可以使用这个对象的一些方法获取这些信息。
  ** 例如:
     *** getMessage() 方法,用来得到有关异常事件的信息。
  *** printStackTrace() 方法,用来 跟踪异常事件发生时执行堆栈的内容。
* finally 语句
  ** finally 语句为异常处理提供一个统一的出口,使得在控制流程转到程序的其他部分以前,能够对程序的状态作统一的管理。
  ** 无论 try 所指定的程序块中是否抛出例外,finally 所指定的代码都要被执行。
  ** 通常在 finally 语句中可以进行资源的清除工作,如:
     *** 关闭打开的文件。
  *** 删除临时文件。
  *** ...
 
 
 
自定义异常: 
* 使用自定义异常一般有如下步骤:
  1、通过继承 java.lang.Exception 类声明自己的异常类。(也可以继承其它的异常类,但不推荐,如果你继承是的 java.lang.RuntimeException 异常类,则表示从你这个自定义的异常类里抛出的异常也是可捕获可不捕获的!)
  2、在方法适当的位置生成自定义异常的实例,并用 throw 语句抛出。
  3、在方法的声明部分用 throws 语句声明该方法可能抛出的异常。
* 例子程序:
public class MyException extends Exception {
 private int id;
 
 MyException( String _message, int _id ) {
 
  super( _message );
  this.id = _id;
 
 }
 
 public int getId() {
 
  return this.id;
 
 }
 
 public static void main(String[] args) throws Exception{
 
  try {
   if(args.length != 2) throw new MyException("username or userpassword is null!", 001);
   if("null".equals(args[0])) throw new MyException1("username is null!", 002);
   if("".equals(args[1])) throw new MyException("userpassword is null!", 003);
   System.out.println("尊敬的黄金VIP:" + args[0] + ",欢迎您!");
  } catch(MyException me) {
   me.printStackTrace();
   //System.out.println("Error");
  }
 
 }
}
 
 
 
注意:重写方法需要抛出与原方法所抛出异常类型一致的异常,或者不抛出异常,其它的所有情况都不行,抛出的异常范围大了不行,小了不行,个数不一样也不行。 
 
 
 
总结: 
* 一个图。
* 五个关键字。
* 先逮小的,再逮大的。
* 异常和重写的关系。

以上是关于java异常3-19的主要内容,如果未能解决你的问题,请参考以下文章

Java异常-可能会出现异常丢失的情况&finally

每日一题:Java异常处理

java异常复习

Java中的异常

Java异常处理的基础知识

FIFO可能会发生Belady异常,堆栈算法不会发生Belady异常,如LRU。证明为何不会异常。