Java学习笔记之throw、 throws 、finally详解

最新推荐文章于 2024-11-21 16:42:45 发布

yxf18

最新推荐文章于 2024-11-21 16:42:45 发布

阅读量940

点赞数

CC 4.0 BY-SA版权

分类专栏： java 文章标签： java throw throws

本文链接：https://blog.csdn.net/qq_42006583/article/details/80016206

java 专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了Java中的异常处理机制，包括throw和throws的区别与用法，检查性异常与非检查性异常的特点，以及finally块的功能和执行时机。通过具体代码示例展示了异常处理的实际应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、throw、throws详解

•throw

抛出一个异常

用法:Way1：throwsnew Exception();//常写为一个语句，抛出一个异常

Way2：Exceptione=new Exception();//像使用类和对象一样，创建一个异常

throw e; //再它抛出

异常的抛出：有两种方式：系统自己抛出或用throw抛出

异常抛出后，后面的语句都不执行了它直接去找catch或者 throws

•throws

它是一种对异常的声明，常写再函数后面，表示这个函数可能会出现某些异常；

格式如下：

Voidf2( ) throws Exception

{

inta=4/0; //系统自动抛出异常

}

Exception是所有异常的父类，如果将它写在catch里面，可以捕获任何类型的异常，因为子类可以赋给父类。

void f1( )throws Exception

{

inta=4/2; //没有异常

}

void f3( )throws Exception

{

thrownew Exception();

//用throw语句抛出异常

}

也可以自己写一个类继承Exception 如calssmyException extends Exception

throws的作用：

它的作用就是(机器比喻)，一旦它看到这个函数出现了异常，它立刻将这个异常抛给给调用这个函数的上一级函数(相当于上报)，让上一级函数去处理它。

如果是主函数调用的f函数，那么上一级函数就是主函数；

如果是其他函数调用的f函数，那么上一级就是其他函数。

上一级函数处理:要么捕获它，要么抛出它(如果是检查性异常，需要用throw抛出；非检查性异常自动抛出)

二、检查性异常和非检查性异常

•检查型异常：要么抛出，要么捕获。如果new Exception一个对应函数必须有throws声明或者用catch去捕获。

•也就是说，如果一个函数里面抛出了一个检查型异常，要么在本函数内直接用try处理了。要么在函数开头写throws声明，那么必须在它的上一级函数写try或者 throws 去继续处理它，否则编译不会让你过。

•通过throws可以一层一层向上抛出，直到被try处理或者抛出主函数。

•非检查型异常：系统自动抛出可以不写throws去上报、也不必写catch去捕获它。它会自动抛出，抛出路径是，从一层一层向它的上一级函数抛出，直到有try去捕获它，或者直到抛出主函数位置，抛出主函数就是交给虚拟机去处理，一般程序就会终止。

•两个测试实例t1、t2

public class t1{
public static void main() 
{
	A a=new A();
	try{
	a.B();
	}
	catch(Exception e)
	{
		System.out.println("hello!");
	}
}
}

class A{
	
	
	
	void B()
	{
		C();
	}
	void C()
	{
		D();
	}
	void D()
	{
		paochu();
	}
	void paochu() 
	{
		throw new IllegalArgumentException();//非检查性异常
	}
	
}

import java.io.IOException;


public class t2 {
	public static void main(String[]args)throws Exception
	{
	try{
		P a=new P();
		a.A();
	}
	catch ( IOException e)
	{
		System.out.println("Catch!");
		
	}
		
	}


}

class P{

	 void A() throws IOException
	 {
		 B();
	 }
	 void B() throws IOException
	 {
		 C();
	 }
	 void C() throws IOException
	 {
		 D();
	 }
	void D() throws IOException
	{
		setRadius();
	}
	 
	 void setRadius() throws IOException {
	  
	      throw new IOException();
	  }
}

•如果try…catch throws同时用呢？

既在同一个函数里面，抛出一个异常，既在函数中声明了throws 又用try去处理了它，会出现怎么样的情况？

•测试实例t3

public class t3 {
	public static void main(String[]args)
	{
		try{
			
		f();
		}
		catch(Exception e)
		{
			System.out.println("catch in main");
		}
		
	}
	
	public static void f() throws Exception
	{
		try
		{
			throw new Exception();
			
		}
		catch(Exception e)
		{
			System.out.println("catch in f");
		}
	}
}

测试结果：catch优先于 throws

三、finally

•finally写在try…catch…之后，可要可不要

•finally的代码一定会执行，即使无论上面catch捕未捕获到异常或者在catch再抛出一个异常，或者cacth里面有retrun

•也会先finally再return先finally再抛出cacth中的异常

•测试实例t4

public class t4 {
	public static void main(String[]args) 
	{
		
		f1();
		
//		f2();
	}
	public static void f1()
	{
		try
		{
			throw new Exception();
		}
		catch(Exception e)
		{	System.out.println("f cacth");
			return;
		}
		finally
		{
			System.out.println("I'm in finally");
		}
	}
	public static void f2() throws Exception
	{
		try
		{
			throw new Exception();
		}
		catch(Exception e)
		{	System.out.println("f cacth");
			throw new Exception();
		}
		finally
		{
			System.out.println("I'm in finally");
		}
	}
}

四、练习

下列程序输出结果是？

public class t5 {
public static void main(String[]args)
{

int i=0;
try
{
for(i=0;i<10;i++)
{
try
{
if(i%3==0)
throw new Exception();
System.out.println("1:"+i+",");
}
catch(Exception e2)
{
System.out.print("2:"+i+",");
i+=2;
if(i%3==2)
throw new Exception();
return;
}
finally
{

i*=2;
System.out.print("3:"+i+",");
}

}
}
catch(Exception e2)
{
System.out.print("4:"+i+",");
return;
}
finally
{
System.out.print("5:"+i);
}

}

}

答案是：2:0,3:4,4:4,5:4