求如何在其他类中调用自定义异常类中的异常处理方法

Question

[size=12px]import java.io.*;
class excep
{
    /*excep() throws Exception//建立excep()构造方法并抛出Exception类异常
    {
     }*/
public int division(int a,int b) throws Exception,divisione//同时抛出多个异常。 { if(b<0)
{
throw new divisione("Divisor can't be minus!!!");
}
return a/b;     
}
/*public int fn1(int c,int d) throws Exception,divisione//同时抛出多个异常
{
return division(c,d);//调用division方法，并返回。
}*/ //在该程序中，这个方法没有被调用。
}class childexcep extends excep //子类childexcep继承父类excep，并覆盖了父类的方法。
{
    /*childexcep() throws FileNotFoundException/
{
}*/
public int division(int a,int b) throws Exception,divisione
{
 if(b<0)
{
throw new divisione("Divisor can't be minus!!");
}
 return a/b;
}
}
class divisione extends Exception //自定义异常类。定义的所有的异常类都继承通用异常类Exception
{
divisione (String s) //建立类divisione的构造方法。
{
super(s);//调用父类Exception中的被隐藏的具体异常类方法。
}
}class test
{
public static int method1(excep z)//建立一个方法，接收类excep的对象e
{
try
{
   return z.division(5,-1);
   }  
   catch(Exception m)
  {
   System.out.println("ArithmeticException:Can't divide by zero!");
   }
   catch(divisione j)//如果调用e.fn1(5,-1);方法，捕获并处理这条除数不能为负数的异常
   {
System.out.println("除数不能为负数！");                                                                                 System.out.println(j.toString());
    }//已捕获异常，却不能处理？？？？？？？？？？
    return 0;    
}

public static void main(String[] args)
{
excep e=new excep();//建立类excep的实例化对象e
childexcep ex=new childexcep();
method1(ex);      
System.out.println("finish");
}
}上面代码已捕获divisione异常，却没有处理，到底什么原因，应该怎么改代码？
而把这段代码直接复制到main函数如下，却能够执行。
public static void main(String[] args)
{
excep e=new excep();//建立类excep的实例化对象e
childexcep ex=new childexcep();
method1(ex);      

                                    try
{
   return z.division(5,-1);
   }  
   catch(Exception m)
   {
   System.out.println("ArithmeticException:Can't divide by zero!");
   }
   catch(divisione j)//如果调用e.fn1(5,-1);方法，捕获并处理这条除数不能为负数的异常
    {
System.out.println("除数不能为负数！");                                                                                 System.out.println(j.toString());
    }
                                                      System.out.println("finish");
}
[/size]

Answer 1

因为已经被第一个捕获了就不会往下走了呀，因为你第一个是Excepton捕获

Answer 2

只有当b=0时，被第一个catch(Excepton)；当b=-1时，第一个catch(Excepton)并没有捕获，而是被第二个catch(divisione)捕获。

Answer 3

只有当b=0时，被第一个catch(Excepton)；当b=-1时，第一个catch(Excepton)并没有捕获，而是被第二个catch(divisione)捕获。这只是你这么认为吧，catch(Excepton)会捕获所有异常

Answer 4

只有当b=0时，被第一个catch(Excepton)；当b=-1时，第一个catch(Excepton)并没有捕获，而是被第二个catch(divisione)捕获。这只是你这么认为吧，catch(Excepton)会捕获所有异常u但如果是这样的话，为什么把捕获异常的语句放在主函数（main）中，又能捕获catch(divisione)异常并处理了呢？而把try\catch语句放在主函数外就不能处理？？

Answer 5

       但如果是这样的话，为什么把捕获异常的语句放在主函数（main）中，又能捕获catch(divisione)异常并处理了呢？而把try\catch语句放在主函数外就不能处理？？
public static void main(String[] args)
{
excep e=new excep();//建立类excep的实例化对象e
childexcep ex=new childexcep();
try
{
ex.fn1(5,-1); 
                        System.out.println("exception");
                         return;
   }
  catch(ArithmeticException m)
  {
   System.out.println("ArithmeticException:Can't divide by zero!");
   }
   catch(divisione j)//如果调用e.fn1(5,-1);方法，捕获并处理这条除数不能为负数的异常
   {
    System.out.println("除数不能为负数！");
    System.out.println(j.toString());
    }
  catch (Exception n)/。
  {
   System.out.println("Can't divide by zero!!!");//自己定义输出的字符串。
   System.out.println(n.getMessage());
   System.out.println(n.toString());
   n.printStackTrace();
   }
   finally
   {
   System.out.println("finally!");
   }      
System.out.println("finish");
}

Answer 6

还是这个看着清晰明了，你把catch(divisione j)和catch (Exception n)颠倒一下顺序试一下，看会捕获到啥

Answer 7

还是这个看着清晰明了，你把catch(divisione j)和catch (Exception n)颠倒一下顺序试一下，看会捕获到啥哥们看你等级这么高，现实中工作了多少年了？想了解下！

Answer 8

还是这个看着清晰明了，你把catch(divisione j)和catch (Exception n)颠倒一下顺序试一下，看会捕获到啥哥们看你等级这么高，现实中工作了多少年了？想了解下！不要被表象所迷惑，每天都来逛逛，几个月等级就上去了

Answer 9

颠倒了也不行，我就是把catch(Exception)语句注释掉都通不过编译。如下：
class test
{
public static int method1(excep z)//建立一个方法，接收类excep的对象e
{
try
{
   return z.division(5,-1);
   }  
  /* catch(Exception m)
  {
   System.out.println("ArithmeticException:Can't divide by zero!");
   }*/
   catch(divisione j)//如果调用e.fn1(5,-1);方法，捕获并处理这条除数不能为负数的异常
   {
System.out.println("除数不能为负数！");
System.out.println(j.toString());

    }
    return 0;    
}

public static void main(String[] args)
{
excep e=new excep();//建立类excep的实例化对象e
childexcep ex=new childexcep();
method1(e);      
System.out.println("finish");//验证是否执行该条语句。这条代码也能执行了。但是如果主函数中的try语句有return语句时，其没有发生异常时，该条语句就不再执行。但finally语句还是会执行。
}
}但是如果我是这样编写，就能通过编译并能够捕获自定义异常类divisione和处理异常。代码如下：class test
{
public static void main(String[] args)
{
excep e=new excep();//建立类excep的实例化对象e
childexcep ex=new childexcep();
try
{
ex.fn1(5,-1);
      //ex.division(5,-1);//调用子类的division方法。子类的division方法覆盖了父类中的division方法。
      System.out.println("exception");
      return;
   }
  catch(ArithmeticException m)
  {
   System.out.println("ArithmeticException:Can't divide by zero!");
   }
   catch(divisione j)//如果调用e.fn1(5,-1);方法，捕获并处理这条除数不能为负数的异常
   {
    System.out.println("除数不能为负数！");
    System.out.println(j.toString());
    }
  catch (Exception n)
  {
   System.out.println("Can't divide by zero!!!");//自己定义输出的字符串。
   System.out.println(n.getMessage());
   System.out.println(n.toString());
   n.printStackTrace();
   }
   finally
   {
   System.out.println("finally!");
   }      
System.out.println("finish");
}
}其输出结果如下：
除数不能为负数！
divisione:Divisor can't be minus!!
finally!
finish

Answer 10

       不好意思。颠倒过来确实能捕获到。我终于想起来了！在java中可以用具体异常类来捕获异常（如ArithmeticException），也可以用非具体异常类捕获异常（如：Exception），而且可以有多个catch语句来捕获同一个异常。一般先打印具体异常类，如果非具体异常类也捕获相同的异常，则不再打印非具体类捕获的异常了。但是如果具体类异常捕获catch语句放在非具体类异常捕获catch语句的后面，就会产生错误。        原来犯了一个低级错误，绕不过弯来。谢谢大神解惑！！！
        最后吐一下。发帖的验证码字太小了，折磨人啊。