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

mikewxm 2016-10-26 11:09:06
[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]
...全文
392 12 打赏 收藏 转发到动态 举报
写回复
用AI写文章
12 条回复
切换为时间正序
请发表友善的回复…
发表回复
尼古拉斯-全蛋 2016-10-27
  • 打赏
  • 举报
 回复
引用 4 楼 mikewxm 的回复:
[quote=引用 3 楼 King__Jrj 的回复:] 因为已经被第一个捕获了就不会往下走了呀，因为你第一个是Excepton捕获
只有当b=0时，被第一个catch(Excepton)；当b=-1时，第一个catch(Excepton)并没有捕获，而是被第二个catch(divisione)捕获。[/quote] 这只是你这么认为吧，catch(Excepton)会捕获所有异常
mikewxm 2016-10-27
  • 打赏
  • 举报
 回复
引用 3 楼 King__Jrj 的回复:
因为已经被第一个捕获了就不会往下走了呀，因为你第一个是Excepton捕获
只有当b=0时，被第一个catch(Excepton)；当b=-1时，第一个catch(Excepton)并没有捕获，而是被第二个catch(divisione)捕获。
mikewxm 2016-10-27
  • 打赏
  • 举报
 回复
不好意思。颠倒过来确实能捕获到。我终于想起来了！在java中可以用具体异常类来捕获异常（如ArithmeticException），也可以用非具体异常类捕获异常（如：Exception），而且可以有多个catch语句来捕获同一个异常。一般先打印具体异常类，如果非具体异常类也捕获相同的异常，则不再打印非具体类捕获的异常了。但是如果具体类异常捕获catch语句放在非具体类异常捕获catch语句的后面，就会产生错误。 原来犯了一个低级错误，绕不过弯来。谢谢大神解惑！！！ 最后吐一下。发帖的验证码字太小了，折磨人啊。
mikewxm 2016-10-27
  • 打赏
  • 举报
 回复
颠倒了也不行，我就是把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
尼古拉斯-全蛋 2016-10-27
  • 打赏
  • 举报
 回复
引用 9 楼 King__Jrj 的回复:
[quote=引用 8 楼 qnmdcsdn 的回复:] [quote=引用 7 楼 mikewxm 的回复:] 但如果是这样的话，为什么把捕获异常的语句放在主函数（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");
				}
还是这个看着清晰明了，你把catch(divisione j)和catch (Exception n)颠倒一下顺序试一下，看会捕获到啥[/quote] 哥们看你等级这么高，现实中工作了多少年了？想了解下！[/quote] 不要被表象所迷惑，每天都来逛逛，几个月等级就上去了
从小就很呆 2016-10-27
  • 打赏
  • 举报
 回复
引用 8 楼 qnmdcsdn 的回复:
[quote=引用 7 楼 mikewxm 的回复:] 但如果是这样的话，为什么把捕获异常的语句放在主函数（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");
				}
还是这个看着清晰明了，你把catch(divisione j)和catch (Exception n)颠倒一下顺序试一下，看会捕获到啥[/quote] 哥们看你等级这么高，现实中工作了多少年了？想了解下！
尼古拉斯-全蛋 2016-10-27
  • 打赏
  • 举报
 回复
引用 7 楼 mikewxm 的回复:
但如果是这样的话，为什么把捕获异常的语句放在主函数（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");
				}
还是这个看着清晰明了，你把catch(divisione j)和catch (Exception n)颠倒一下顺序试一下，看会捕获到啥
mikewxm 2016-10-27
  • 打赏
  • 举报
 回复
但如果是这样的话，为什么把捕获异常的语句放在主函数（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");
				}
mikewxm 2016-10-27
  • 打赏
  • 举报
 回复
引用 5 楼 qnmdcsdn 的回复:
[quote=引用 4 楼 mikewxm 的回复:] [quote=引用 3 楼 King__Jrj 的回复:] 因为已经被第一个捕获了就不会往下走了呀，因为你第一个是Excepton捕获
只有当b=0时，被第一个catch(Excepton)；当b=-1时，第一个catch(Excepton)并没有捕获，而是被第二个catch(divisione)捕获。[/quote] 这只是你这么认为吧，catch(Excepton)会捕获所有异常[/quote]u 但如果是这样的话，为什么把捕获异常的语句放在主函数（main）中，又能捕获catch(divisione)异常并处理了呢？而把try\catch语句放在主函数外就不能处理？？
mikewxm 2016-10-26
  • 打赏
  • 举报
 回复
第一次发帖没注意。现在想重新编辑又说权限不够。
渺_渺 2016-10-26
  • 打赏
  • 举报
 回复
在编辑器里有代码的编辑，加上这个
，你的代码可读性更好，现在显得很乱
从小就很呆 2016-10-26
  • 打赏
  • 举报
 回复
因为已经被第一个捕获了就不会往下走了呀，因为你第一个是Excepton捕获
Android EventBusDemo
代码为博客实例代码：http://blog.csdn.net/lmj623565791/article/details/40794879 有问题博客留言
如何自定义异常类
在 Java 中，自定义异常是指用户根据自己的需求创建的异常类。Java 提供了一些预定义的异常类，如等，但有时这些预定义的异常类并不能完全满足我们的需求。在这种情况下，我们可以通过创建自定义异常类来表示特定的异常情况。自定义异常类通常继承自Exception类或类，以及它们的子类，并根据需要添加相应的构造方法和其他方法以满足特定的异常处理需求，自定义异常类可以包含额外的属性和方法，以提供更多的信息和功能。使用自定义异常类时，通常的做法是在方法中使用throw。
java常见异常处理方式-自定义异常
自定义异常是开发者根据业务需求和逻辑自行定义的异常类，通常用于处理应用程序中特定的错误情况或违反业务规则的情形。通过创建自定义异常，可以使代码更具可读性，并且在发生错误时提供更有用的上下文信息。Java中的自定义异常通常继承自`Exception`或`RuntimeException`，取决于异常的类型和使用场景：- **继承自`Exception`**：创建受检异常（Checked Exception）。这种异常要求调用者显式地捕获或声明抛出，适用于强制调用者处理的异常情况。
Java编程：自定义异常案例（多个异常处理）
用户只需要继承Exception类即可自定义异常类。在程序中使用自定义异常类，大体可分为以下几个步骤：1、创建自定义异常类。2、在方法中通过throw关键字抛出异常对象。3、如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。4、在出现异常的方法的调用者中捕获并处理异常。...
Java自定义异常处理
首先，你需要创建一个继承自Exception或的类。选择哪个取决于你的需求：如果希望强制调用者处理该异常，应该继承自Exception；如果可以选择不处理该异常，应该继承自。// 自定义检查异常在你的代码中，你可以在需要的地方抛出这个自定义异常。throw new MyCustomException("值不能为负数: " + value);} else {System.out.println("值是: " + value);在调用可能抛出自定义异常的方法时，你需要捕获并处理该异常。
Java SE

62,628

社区成员

307,259

社区内容

发帖
与我相关
我的任务
社区描述
Java 2 Standard Edition
社区管理员
  • Java SE
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章