请教一个简单异常处理的方法。

我在自己的项目里定义了一个DumbassException异常，这是用来定义自己项目的一场。
DumbassException继承Exception。
看了很多源码，有些事这样的处理的，在方法后throws **,然后在catch中又重新throw new **Exception().
但是又有些代码，在catch中不做处理。
哪位高手能解释一下，何时throw,何时不用throw?

偶一直觉得异常处理，很多项目里没有一个定论。


package watson.wpro.exception;

import java.io.PrintStream;
import java.io.PrintWriter;

public class DumbassException extends Exception {
private static final long serialVersionUID = 1L;
private Throwable cause = null;
private Exception orgException = null;

public DumbassException() {
super();
}

public DumbassException(String message) {
super(message);
}

public DumbassException(String message, Throwable cause) {
super(message);
this.cause = cause;
}

public String getMessage() {
if (cause != null) {
return super.getMessage() + "-" + cause.getMessage();
} else {
return super.getMessage();
}
}

public void printStackTrace() {
super.printStackTrace();
if (cause != null) {
cause.printStackTrace();
}
}

public void printStackTrace(PrintStream ps) {
super.printStackTrace(ps);
if (cause != null) {
cause.printStackTrace(ps);
}
}

public void printStackTrace(PrintWriter pw) {
super.printStackTrace(pw);
if (cause != null) {
cause.printStackTrace(pw);
}
}

public Exception getOrgException() {
return orgException;
}

public void setOrgException(Exception exception) {
this.orgException = exception;
}
}

20 个解决方案

#1

自己顶一下。

#2

帮你顶一下。

#3

throws在定义方法时把异常就向上抛了
而try-catch是自己捕获的，选择的时候因程序的需要而定。

#4

如果你确定能处理好当前的错误  那你就catch它  并处理它

如果你不能  就抛出去  一起处理   或者有时候两个方法抛出同类型的错误  你可以一起抛出 同时处理

#5

是啊，好像不很固定。
有些小问题需要在发生的时候马上处理，就需要try后面紧跟上个catch处理一下。
但如果调用这个方法的主方法还好依赖与执行这个方法是否有异常产生，或是需要到外面主方法中统一对各个细节中抛出的异常进行处理的话，就需要抛出去，显示抛与隐式抛都可以的。

#6

项目里大家对异常的处理有没有什么契约?

#7

这确实是一个问题，没有确切的答案，得根据实际的需要。
在出现异常的地方也有两种解决方案：
1，出现的异常需要自己捕捉，并且要做一定的其他操作。
   例如在出异常的时候需要把一些信息出力到log里。
2，出现的异常不需要自己捕捉，但是你已经预测到他会有异常
   此时，你只需要他的上一级抛异常，又上一级做处理。
以上只是个人的见解，你可以找些书好好研究一下。

#8

up

#9

等待高手出现!

#10

我觉得是否throw是对方法使用者而言.如果方法出现异常,然并未影响到方法的功能,则就在方法内try catch即可;如果方法中的异常直接影响到方法的功能,那就需要向上throw了,从而告诉使用者,方法并没有达到预期的效果。
呵呵,个人愚见.

#11

引用 7 楼 ouyangxiaokang6 的回复:

这确实是一个问题，没有确切的答案，得根据实际的需要。 
在出现异常的地方也有两种解决方案： 
1，出现的异常需要自己捕捉，并且要做一定的其他操作。 
  例如在出异常的时候需要把一些信息出力到log里。 
2，出现的异常不需要自己捕捉，但是你已经预测到他会有异常 
  此时，你只需要他的上一级抛异常，又上一级做处理。 
以上只是个人的见解，你可以找些书好好研究一下。

得解

#12

引用 7 楼 ouyangxiaokang6 的回复:

这确实是一个问题，没有确切的答案，得根据实际的需要。 
在出现异常的地方也有两种解决方案： 
1，出现的异常需要自己捕捉，并且要做一定的其他操作。 
  例如在出异常的时候需要把一些信息出力到log里。 
2，出现的异常不需要自己捕捉，但是你已经预测到他会有异常 
  此时，你只需要他的上一级抛异常，又上一级做处理。 
以上只是个人的见解，你可以找些书好好研究一下。

想问一下：如果上一级处理不了，是不是再次往上抛呢？

#13

想问一下：如果上一级处理不了，是不是再次往上抛呢？ 
---------------------
上一级要再抛出异常,再往上一级做异常处理!

#14

引用 13 楼 hdhai9451 的回复:

想问一下：如果上一级处理不了，是不是再次往上抛呢？ 
--------------------- 
上一级要再抛出异常,再往上一级做异常处理! 

那什么时候是个尽头哦！

#15

我的理解是出来混迟早都要还的，遇到异常就捕获它吧，你抛出的话，迟早都要还的，除非。。。。。

#16

不会

#17

自己顶一下。

问题是在什么合适的时候throw new ***exception,需不需要抛出，是不是跟业务逻辑有一定的关系。

#18

自顶

#19

自顶

#20

在项目中，对未知的异常，通常不要尝试自己捕获，选择throw,最后在出错时，好定位原因
而对于可能预知的异常，可以使用try catch，但别忘了做另一件事，catch的同时你得把log存下去，

#21

• 程序员应该如何去请教别人问题