1. /*自定义的异常*/
   
2. class MyDivFuShuException extends Exception {
   
3.         public MyDivFuShuException(String message) {
   
4.                 super(message);
   
5.         }
   
6. }
   
7. 
   
8. public class ZidingyiException {
   
9.         public static void main(String[] args) {
   
10.                 try {
    
11.                         div(1, -1);
    
12.                 } catch (MyDivFuShuException e) {// 这里捕获的是方法中抛出的异常
    
13.                         System.out.println(e.getMessage());
    
14.                 }
    
15.                 try {
    
16.                         div1(1, -1);
    
17.                 } catch (MyDivFuShuException e) {// 这里捕获自定一的异常，但是方法中没有抛出才异常，不是即使不会出现的异常的，也可以在这里进行捕获呢啊，那为什么还会出错呢
    
18.                         System.out.println(e.getMessage());
    
19.                 } catch (ArithmeticException e) {// 这里编译不会出错误，这是现有的异常类，捕获不出错误，但是为什么自定义的异常就会出错误呢
    
20.                         System.out.println(e.getMessage());
    
21.                 }
    
22.         }
    
23. 
    
24.         /* 自定义的异常 把异常抛出 */
    
25.         public static void div(int a, int b) throws MyDivFuShuException {
    
26.                 if (b < 0)
    
27.                         throw new MyDivFuShuException("自定义的异常，除数不能为零");
    
28.                 System.out.println(a / b);
    
29.         }
    
30. 
    
31.         /* 自定义的异常 在本方法中就把异常抛出 */
    
32.         public static void div1(int a, int b) {
    
33.                 try {
    
34.                         if (b < 0)
    
35.                                 throw new MyDivFuShuException("自定义的异常，除数不能为零");
    
36.                         System.out.println(a / b);
    
37.                 } catch (MyDivFuShuException e) {
    
38.                         System.out.println(e.getMessage());
    
39.                 }
    
40.         }
    
41. 
    
42. }
    

复制代码

请大家帮忙解答一下我的疑问！

对于自定义的异常，必须在方法上声明异常，或者方法内抛出异常对象，调用者才能捕获，记住这个结论就行了，没必要追根究底啊，我觉得追根究底也没有好处，反正方法不抛自定义的异常调用的时候捕获自定义异常就不能编译通过，其实理解起来也蛮简单的，你想一下一个自定义异常你要不在方法上抛出来，java虚拟机怎么知道调用方法会产生你自定义的异常，它只能知道系统本身自带的异常。

1. /*自定义的异常*/
   
2. class MyDivFuShuException extends Exception {
   
3.         public MyDivFuShuException(String message) {
   
4.                 super(message);
   
5.         }
   
6. }
   
7. 
   
8. public class ZidingyiException {
   
9.         public static void main(String[] args) {
   
10.                 try {
    
11.                         div(1, -1);
    
12.                 } catch (MyDivFuShuException e) {// 这里捕获的是方法中抛出的异常
    
13.                         System.out.println(e.getMessage());
    
14.                 }
    
15.                 try {
    
16.                         div1(1, -1);
    
17.                 }
    
18.                 /*catch (MyDivFuShuException e) {// 此处自己定义的异常已在方法中被catch处理掉
    
19.                         System.out.println(e.getMessage());
    
20.                 }*/
    
21.                 catch (ArithmeticException e) {// 这里编译不会出错误，这是现有的异常类，捕获不出错误，但是为什么自定义的异常就会出错误呢
    
22.                         System.out.println(e.getMessage());
    
23.                 }
    
24.         }
    
25. 
    
26.         /* 自定义的异常 把异常抛出 */
    
27.         public static void div(int a, int b) throws MyDivFuShuException {
    
28.                 if (b < 0)
    
29.                         throw new MyDivFuShuException("自定义的异常，除数不能为零");
    
30.                 System.out.println(a / b);
    
31.         }
    
32. 
    
33.         /* 自定义的异常 在本方法中就把异常抛出 */
    
34.         public static void div1(int a, int b) {
    
35.                 try {
    
36.                         if (b < 0)
    
37.                                 throw new MyDivFuShuException("自定义的异常，除数不能为零");
    
38.                         System.out.println(a / b);
    
39.                 } catch (MyDivFuShuException e) {
    
40.                         System.out.println(e.getMessage());
    
41.                 }
    
42.         }
    
43. 
    
44. }

复制代码

也就是说try....catch是为破获别人的exception用的，而throw是自己抛出exception让别人去破获的
div1方法的异常在方法内已被方法中的try catch处理了

自定义异常 前提是继承异常类Exception，如果我们定义的是运行时期异常，继承RuntimeException；
需要将异常的信息，传递给自定义异常的父类，用super(),如果你用try{}catch(){}进行处理，如果在try{}中没有捕获到异常，那么就不会再catch(){}中显示出异常来

增哥，div1方法中的和主函数的try  catch方法，只留下其中以组就可以了。
div1方法虽然抛出了异常，但是被方法内部捕捉了。抛不到主函数那边去。
也就是说，这个异常对于主函数来说，相当于没有异常。那么定义捕捉方法是没意义的。

黄炳期 发表于 2013-9-7 18:40
增哥，div1方法中的和主函数的try  catch方法，只留下其中以组就可以了。
div1方法虽然抛出了异常，但是被 ...

我知道，在那里捕获那个自定义异常没有意义，我就是想知道，为什么在捕获不会出现的现有的异常(例如：被零除的异常)就不会出错，但是捕获捕获不会出现的自定义的的异常就会出错呢？？？

31.        /* 自定义的异常 在本方法中就把异常抛出 */

32.        public static void div1(int a, int b) 这里加throws MyDivFuShuException}

33.                try {

34.                        if (b < 0)

35.                                throw new MyDivFuShuException("自定义的异常，除数不能为零");

36.                        System.out.println(a / b);

37.                } catch (MyDivFuShuException e) {

38.                        System.out.println(e.getMessage());

39.                }

40.        }