关于异常处理的

黄玉昆

在java中怎样进行异常处理？

赵晓东 · 赵晓东

我自己总结的，我的学习日志，你看看吧

异常是对问题的描述，将问题进行对象的封装。
异常类：
Throwable
|
|——Error
|——Exception
异常的处理：
java提供了特有的语句进行处理
try
{
需要被检测的代码；
}
catch(异常类，变量)
{
处理异常的代码（处理方式）；
}
finally
{
一定会执行的代码，通常用于关闭资源；
}
例：
/*
异常示例
*/
class Demo
{
public static int method(int a,int b)
{
return a/b; //除数为0，抛出异常
}
}
class ExceptionDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.method(5,0); //传递参数，除数为0，并抛出异常
System.out.println("x="+x);//这里将不会执行
}
catch (Exception e) //接收异常
{
System.out.println("除数为0");
}
System.out.println("over~");
}
}
对捕获到的异常对象进行常见方法操作：
String getMessage() 获取异常信息
String toString() 异常名称：异常
void printStackTrace() 异常名称，异常信息，异常出现位置，JVM默认调用的异常处理机制
多个catch块中的异常出现继承关系，父类catch块放在最下面，声明几个异常，对应有几个catch块，
不要定义多余的。
自定义异常：
必须是自定义类继承Exception,异常体系有一个特点：因为异常类和异常对象都被抛出，他们都具备
可抛性，这个可抛性是Throwable这个体系中独有特点。只有这个体系中的类和对象才可以被throws
和throw操作。
1>为了让该自定义类具备可抛性。
2>让该类具备操作异常的共性方法。
throws和throw的区别
throws使用在函数上，throw使用在函数内。
throws后面跟的是异常类，可以跟多个，用逗号隔开，throw后面跟的是异常对象。
例：
/*
自定义异常示例
*/
class CustomException extends Exception//自定义异常类
{
private int value;
CustomException(String message,int value)
{
super(message);//类CustomException继承于Excetpion，并且父类中已定义getMessage方法
this.value = value;
}
public int getValue()
{
return value;
}
}
class ExceptionDemo
{
public static int method(int a,int b) throws CustomException
{
if (b < 0)
throw new CustomException("除数出错~",b);//抛出异常对象
return a / b;
}
}
class CustomExceptionTest
{
public static void main(String[] args)
{
ExceptionDemo ed = new ExceptionDemo();
try
{
int x = ed.method(5,-3);
System.out.println(x);
}
catch (ArithmeticException e)//处理异常
{
System.out.println(e.toString());
System.out.println("除数为0");
}
catch(CustomException e)//处理异常
{
System.out.println(e.toString());
System.out.println("出错值为："+e.getValue());
}
System.out.println("over");
}
}
当要定义自定义异常的信息时，可以使用父类已经定义好的功能，将异常信息传递给父类的构造函数。
Exception中有一个特殊的子类异常，RuntimeException运行时异常。如果在函数内抛出该异常，函数上可以不用声明，
编译一样通过。

复制代码

何仕映 · 何仕映

本帖最后由何仕映于 2013-3-16 21:19 编辑

Java异常处理通过5个关键字try、catch、throw、throws、finally进行管理。基本过程是用try语句块包住要监视的语句，如果在try语句块内出现异常，则异常会被抛出，你的代码在catch语句块中可以捕获到这个异常并做处理;还有以部分系统生成的异常在Java运行时自动抛出。你也可以通过throws关键字在方法上声明该方法要抛出异常，然后在方法内部通过throw抛出异常对象。finally语句块会在方法执行return之前执行。

在程序中，对于可能出现异常的代码，有两种处理办法：
第一种在方法中用try...catch语句捕获并处理异常，catach语句可以有多个，用来匹配多个异常。代码如下：
public void str(String str)
{
      try
      {
         ...
      }catch(Exception e){
         ...
      }finally{
         ...
      }
}
第二种对于处理不了的异常或者要转型的异常，在方法的声明处通过throws语句抛出异常。代码例如：
public void str(String str) throws MyException
{
      ...
      if(...)
      {
      throw new MyException();
      }
}

常见的异常错误信息如下：
RuntimeException 运行时出现异常
IOException io流异常
SQLException sql语句异常
NullPointerException  空指针异常
ClassNotFoundException  指定的类不存在
ArithmeticException 数字运算异常
FileNotFoundException 打开指定路径名表示文件失败时，抛出的异常
InterruptedException 当线程在很长一段时间内一直处于正在等待、休眠或暂停状态，而另一个线程用Thread类中的iterrupt方法中断它时，抛出的异常
NumberFormatException  字符串不能转换数值类型时抛出异常
等等，以上暂时碰到的异常。(这个是我在论坛上看到的，总结的很好，所以我私人收录了，现在直接给你，共同学习、共同探讨，共同提高)

郝强勇 · 郝强勇

简单易懂一点，一般情况下我们是对需要异常处理的代码用try-catch代码包围一下，也就是手动捕获，捕获到了就在catch代码块中执行一下需要执行的动作，如在后台显示、用日志的形式保存异常和发生的时间、或throw关键字转换成运行时异常等等，但如果是初学者就打印一下就好。如果不去try-catch,就用throws关键字注明抛出，在调用此声明异常的时候在进行处理或继续抛出，技术上可以一直抛给JVM，让JVM处理，但这样意义就不大了。没有具体事例也不太好说这个问题，浅浅的一说，但愿对LZ有点帮助。

HM刘博 · HM刘博

在java中有一个异常体系：Throwable
                                             |--Error
                                             |--Exception
                                                         |--RuntimeException
通过这个异常体系我们可以看出这个体系中的所有类以及建立的对象都具有可抛性，也就是说可以被throw和throws关键字所操作。

然后再给出throw和throws的用法：throw定义在函数内，用于抛出异常对象。throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。

如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try。进行try处理时，我们的处理语句有三种形式：
1.       try
      {
         需要被检测的代码；
      }
      catch ()
      {
                  处理异常的代码；
      }

2.       try
      {
            需要被检测的代码；
      }
      finally
      {
            一定会执行的代码；
      }

3          try
            {
            需要被检测的代码；
            }
         catch ()
         {
      处理异常的代码；
         }
         finally
         {
      一定会执行的代码；
            }
在这里应该注意的是：1，finally中定义的通常是关闭资源代码。因为资源必须释放。2，finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。3，catch是用于处理异常。如果没有catch就代表异常没有被处理过，如果该异常是检测时异常。那么必须声明。

还有一种就是自定义异常，按照java的面向对象思想，将程序中出现的特有问题进行封装。
在自定义异常中，处理方式也是try和throws两种。当调用到抛出异常的功能时，抛出几个就处理几个，一个try对应多个catch，在这里要注意，多个catch时，父类的catch要放在最下边。
当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
例如：  try
      {
      throw new AException();
      }
      catch (AException e)
      {
      throw e;
      }
如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，在抛出和该功能相关的异常。或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道，并处理。也可以将捕获异常处理后，转换新的异常。
try
{
   throw new AException();
}
catch (AException e)
{
      // 对AException处理。
      throw new BException();
}
在这里还应该要注意：
1，子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。
2，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
3，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。

戴乾刚 · 戴乾刚

Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。

Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。

一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。用try来指定一块预防所有“异常”的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的“异常”的类型。

throw语句用来明确地抛出一个“异常”。

throws用来标明一个成员函数可能抛出的各种“异常”。

Finally为确保一段代码不管发生什么“异常”都被执行一段代码。

可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，“异常”的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种“异常”进行处理，堆栈就会展开，直到遇到有处理这种“异常”的try语句。

张宝 · 张宝

异常分为两种

1.编译异常
当我们对java文件进行编译时，就要求我们对产生的异常进行处理，
这种异常就是编译异常。

Exception类以及除了RuntimeException体系中的其它类都是编译异常。

2.运行异常
我们可以不用对其进行处理，如果出现问题，jvm会处理.
               RuntimeException以及其子类都是运行异常
异常Exception的处理方式  1.捕获  2.抛出

捕获

格式
try{
可能出现异常的代码块
}catch(异常类型变量){
对异常进行处理.
}finally{
完成关闭动作(关闭资源)
}

   如果出现异常，那么异常后面的代码不会被执行。

关于异常中常用的方法.
getMessage()
获取异常信息，返回字符串。
toString()
获取异常类名和异常信息，返回字符串。
printStackTrace()
获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

异常处理抛出

throws 异常类型1,异常类型2,...
写在方法上.

抛出是抛给了调用者，如果调用者也没有处理，继续抛出，那么最终就会
抛出给jvm。
         无论是编译异常还是运行异常，我们都可以人为的对其进行处理。

黑马17期-闫东东 · 黑马17期-闫东东

在java中程序出问题有两种情况下

Exception------->解决

Error----------->不能解决

Throwable 这是Exception与Error的父类

Throwable
|-----Exception
|-----Error

命名规范
所有异常都是使用Exception做为后缀
所有的错误都是使用Error做为后缀.

为什么使用异常

对一些情况我们可以使用if条件语句进行判断解决
存在的隐患，为什么还要使用异常？

1.我们使用异常，可以将我们程序中的逻辑代码与异常问题分离。
   而使用if判断操作，是将逻辑代码与判断操作混到一起，
   它会使用程序不清晰。

2.当我们完成某个操作时，这个操作是否执行成功了，我们需要根据执行成功与否
   进行其它操作，但是这个方法它不能进行返回操作，那么这个时候就可以使用
   异常进行处理。

Exception的处理方式  1.捕获  2.抛出

捕获

格式
try{
可能出现异常的代码块
}catch(异常类型变量){
对异常进行处理.
}finally{
完成关闭动作(关闭资源)
}

   如果出现异常，那么异常后面的代码不会被执行。

关于异常中常用的方法.
getMessage()
获取异常信息，返回字符串。
toString()
获取异常类名和异常信息，返回字符串。
printStackTrace()
获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

异常处理抛出

throws 异常类型1,异常类型2,...
写在方法上.

抛出是抛给了调用者，如果调用者也没有处理，继续抛出，那么最终就会
抛出给jvm。

什么时候使用捕获，什么时候使用抛出？
   如果当前问题在方法内可以自己解决，那么我们就进行捕获。
   如果解决不了，那么抛出给调用者，让调用者解决。

异常分类

异常分为两种

1.编译异常
当我们对java文件进行编译时，就要求我们对产生的异常进行处理，
这种异常就是编译异常。

Exception类以及除了RuntimeException体系中的其它类都是编译异常。

2.运行异常
我们可以不用对其进行处理，如果出现问题，jvm会处理.

RuntimeException以及其子类都是运行异常

无论是编译异常还是运行异常，我们都可以人为的对其进行处理。

自定义异常

简单说就是自己做一个类去继承异常类。这就是自定义异常。

为什么要使用自定义异常？

在实际操作中，有些问题，不能使用jdk中提供的异常进行描述，
这个时候我们就可以自已定义异常来对其进行描述。

我们在使用自定义异常时会使用一个关键字  throw

throw作用是抛出异常对象。

HM张超 · HM张超

（1）
try
{
//捕捉异常
}
catch(Exception e)
{
//处理异常
}
finally
{
//无论不现不出现异常必须执行的部分
}
（2）
throws Exception
直接抛出异常

帐号		自动登录	找回密码
密码			加入黑马

关于异常处理的

评分

9 个回复

评分

评分

评分

评分

评分

评分

评分