java中throws和throw的区别_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
java中throws和throw的区别
上传于||暂无简介
大小：1.53KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢请问各位大神java中异常抛出中throw和throws区别是什么？
throws是告诉调用者，抛出一个什么样的异常，即异常的类型；throw是真正抛出一个异常的实例，例如throw new IOException();throw是表示明确抛出一个异常；
throws用在方法声明()的后面，{ 之前，告诉调用此方法的调用者该方法可能抛出的异常，以备调用者捕获，如果该方法抛出的是运行时异常RuntimeException,Error及其子类异常则无须使用throws. 编译时异常得用throws声明java之9天 异常处理,throw 和 throws,finally - 慢慢睁开你的眼睛 - ITeye技术网站
博客分类：
*异常: 就是程序在运行时出现不正常情况
*异常由来: 问题也是现实生活中的事物,也可以通过java类的形式进行描述,并进行封装.
*对于问题的划分:
1: 严重的问题 (Error) :
java通过Error类进行描述,一般不编写针对性的代码进行处理
2: 非严重的问题 (Exception): java通过Exception类进行描述,一般使用针对性的处理方式进行处理
*无论 Error 或者 Exception 都具有一些共性的内容
*比如: 不正常的情况信息,引发原因等
所以就出现了 "Throwable" 这个父类
* Throwable
|--Exception
*2.异常的处理
java 提供了特有的语句进行处理
需要被检测
* }catch(异常类 变量){
出来异常的代码:(处理方式)
* }finally{
一定会执行的语句
* 3.对捕获到的异常信息进行处理
1. String getMessage();
2. String toString();
异常名称 : 异常信息
3. void printStackTrace();
//打印最全名:
异常 名称 : 异常信息
: 异常位置 是 JVM 默认异常处理机制,就是调用这个方法
* 4.问题: 发现下面的程序有时候能正常运行,有时候不能, 因为不是所以认得知道这个方法会抛出异常 ,也不是所有人都会处理 这个异常. 怎么办 ?
所以就出现
class Demo{
static int div(int a,int b){
return a/b;
public class ExceptionDemo {
public static void main(String[] args) {
//exception
int x=Demo.div(4, 0); //除数不能为0 ,抛出 new ArithmeticException(); 程序会终止
System.out.println("x="+x);
//出现异常后
这句话就不会被执行
直接进入 catch 语句块中去了
}catch(Exception e){
// Exceptioin e= new ArithmeticException();
System.out.println("除数为0啦!");
System.out.println(e.getMessage()); // "/ by zero"
System.out.println(e.toString());//toString() 可以省略
异常名称 : 异常信息
e.printStackTrace();
//打印最全名:
异常 名称 : 异常信息
: 异常位置.
System.out.println("run over"); //运行 完
catch语句块后 , 接着运行 这句
byte[] arr=new byte[00];
//超出虚拟据总内存大小
不管在怎么样 也不能超过物理内存大小 ,这程序也没戏了.
throws& 多异常处理
* 1. throws: 在功能上通过throws的关键字声明该功能有可能出现问题.
* 2.被声明后
我们必须告诉程序的处理方式
1.采用 try catch 进行处理
2.继续抛出 异常 ,由jVM 虚拟机 进行异常处理
不过这样 程序 就会终止.
* 多异常的处理
1.声明异常时,建议声明更为具体的异常,这样 处理的可以更具体
比如: 下面 throws ArithmeticException 而不写成 throws Exception
2.对于声明多个异常,在调用的时候就应该有几个 catch块.不要定义多余的catch块 ,比如下面注释的 catch块
如果多个catch中的异常出现了继承关系,父类异常catch块 放在最下面 .
建议:在进行catch处理时,catch一定要定义具体的处理方式
不要简单的一句. e.printStackTrace();
也不要简单的就书写一条输出语句 ,一般采用log日志文件 进行 异常信息记录
class Demo{
static int div(int a,int b) throws ArithmeticException{
return a/b;
class Demo1{
static int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException{
int [] arr=new int[a];
System.out.println(arr[a+1]);
//出现越界
return a/b;
public class ExceptionDemo1 {
public static void main(String[] args) {
// 使用第一种方法处理
Demo.div(4, 0);
} catch (Exception e) {
System.out.println(e.toString());
// 使用第二种方法处理
继续往上抛出异常 让 JVM 帮我处理
public static void otherMethod() throws ArithmeticException{
Demo.div(4, 0);
* 多异常处理
public static void otherMethod1() throws ArithmeticException,ArrayIndexOutOfBoundsException{
Demo1.div(4, 0);
public static void otherMethod2() {
Demo1.div(4, 0);
} catch (ArithmeticException e) {
System.out.println(e.toString());
System.out.println("被0除了");
}catch(ArrayIndexOutOfBoundsException e){
System.out.println(e.toString());
System.out.println("角标越界");
}/*catch(Exception e){
//这样做只会隐藏 异常 ,这样做是不对的
System.out.println(e.toString());
throws 和throw 的区别&&&
自定义 异常类
* 因为项目中会出现特有的问他你.
* 而这些问题并未被java所描述和封装成对象
* 所以对于一些特有的问题可以安装java的对问题封装的思想.
* 将特有的问题,进行自定义的异常封装
* 自定义异常
* 需求: 在本程序中,对于除数 是-1 也视为错误的,是无法进行运算.
* 那么就需要对这个问题进行自定义的描述.
*当函数内部初相了throw抛出异常对象,那么就必须要给对应的处理动作.
*要么在内部 try catch 处理
*要么子啊函数上声明让调用者处理.
*一般情况下, 函数内部出现异常,函数上需要声明.
*发现 打印的结果中只有异常的名称,却没有异常的信息
*因为自定义的异常并未定义信息
*如何定义异常信息呢?
因为父类中已经把异常信息的操作都做完了
所以子类只要在构造时,将异常信息传递给父类通过super语句
就可以直接通过getMessage获取自定义的异常信息
*自定义异常:必须是自定义类继承 Exception
*继承Exception原因:
异常体系有一个特点,因为异常类和异常对象都被抛出
因为他们都具备可抛性,这个可抛性是Trowable这个体系中独有的特点.
只有这个体系中的类和对象才可以被throw 和 throw 操作
*throws 和throw 的区别
*throws:使用在函数上
*throw:使用在函数内
*throws:后面跟的异常类,可以跟多个,用逗号分开
*throw:后跟的是异常对象.
class FuShuException extends Exception{
FuShuException(String msg){
public String getMessage(){
return this.
FuShuException(String msg,int num){
super(msg);
this.value=
public int getValue(){
//自定义 异常类
class Demo{
static int div(int a,int b) throws FuShuException{
throw new FuShuException("出现了除数为零的情况
/ by fushu",b);
//手动通过throw 关键字抛出一个自定义异常对象.
return a/b;
public class ExceptionDemo2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Demo.div(4, -1);
} catch (FuShuException e) {
System.out.println(e.toString());
System.out.println("除数出现负数了!");
System.out.println("负数是:"+e.getValue());
System.out.println("over");
RuntimeException
*RuntimeException:
Exception中有一个非常特殊子类异常,RuntimeException 运行时异常
如果在函数内部使用throw抛出异常,函数上可以不用throws声明,编译一样通过.
如果在函数上使用throws声明了该异常,调用者可以不用进行处理,编译一样通过;
*之所以不用在函数上使用throws声明,是因为不需要让调用者处理
*当异常发送,JVM希望程序停止,因为在运行时,出现了无法继续运算的情况,希望停止程序后,然程序员对代码进行修正
*自定义异常时,如果该异常的发生,无法在继续进行运算,就让自定义异常继承RuntimeException.
*对于异常的分类
*1.编译时被检测的异常 (必须使用 throws 或者 try catch进行处理)
*2.编译时不被检测的异常(运行时异常,RuntimeException以及其子类) 程序会停止掉,然后要改进代码
class Demo{
static int div(int a,int b){ //发现
这里不需要 throws 怎么回事?
throw new ArithmeticException("被零除了!"); //需改 java自定义异常中的提示,改成我们熟悉的
return a/b;
static int div1(int a,int b)throws ArithmeticException{
//if(b==0)
//throw new Exception("被零除了!"); //需改 java自定义异常中的提示
return a/b;
static int div2(int a,int b){ //发现
这里不需要 throws 怎么回事?
throw new FuShuException("出现除数为负数了"); //需改 java自定义异常中的提示
throw new ArithmeticException("被零除了!");
return a/b;
//自定义 运行时异常类
class FuShuException extends RuntimeException{
public FuShuException(String msg) {
super(msg);
public class ExceptionDemo3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
/*Demo.div(4, 0);
Demo.div1(4, 0);
//发现没有 try catch
编译也通过
Demo.div2(4, -9);*/
Teacher t=new Teacher("张老师");
t.prelect();
} catch (NoPlanException e) {
System.out.println(e.toString());
System.out.println("换老师 或者 放假!");
* 老师上课
* 思考上课中出现的问题
比如问题: 电脑蓝屏
要对问题进行封装成对象.
冒烟后,出现讲课进度无法继续
出现了讲师的问题,课时计划无法完成.
throw 和 return 单独存在的时候,后面不能出现 其他语句
class Teacher{
Teacher(String name){
this.name=
this.cmpt=new Computer();
public void prelect()throws NoPlanException{
cmpt.run();
} catch (LanPingException e) {
cmpt.reset();
} catch (MaoYanException e) {
throw new NoPlanException("课时无法继续"+e.getMessage());
//test(); //不能放在这里 ,throw 和 return 单独存在的时候,后面不能出现 其他语句
System.out.println("讲课");
public void test(){
System.out.println("练习!");
class Computer{
private int status=3;
public void run()throws LanPingException,MaoYanException {
if(status==2)
throw new LanPingException("蓝屏了");
if(status==3)
throw new MaoYanException("冒烟了");
System.out.println("电脑运行");
public void reset(){
this.status=1;
System.out.println("电脑重启");
//封装问题
class LanPingException extends Exception{
LanPingException(String message){
super(message);
class MaoYanException extends Exception{
MaoYanException(String message){
super(message);
//冒烟后的异常
class NoPlanException extends Exception{
NoPlanException(String message){
super(message);
* finally代码快:定义一定要执行的代码
* 通常用于关闭资源
* 如果 catch中 有return 的时候
finally 代码会被执行 而其他的代码不会被执行.
class FuShuException extends Exception{
FuShuException(String msg){
super(msg);
class Demo{
static int div(int a,int b)throws FuShuException{
throw new FuShuException("除数为负数!");
return a/b;
class NoException extends Exception{
public class FinallyDemo1 {
public static void main(String[] args) {
除数为负数!
test2(); //
除数为负数!
public static void test1(){
int x=Demo.div(4, -1);
System.out.println("x="+x);
} catch (FuShuException e) {
System.out.println(e.toString());
System.out.println("finally");
System.out.println("over");
public static void test2(){
int x=Demo.div(4, -1);
System.out.println("x="+x);
} catch (FuShuException e) {
System.out.println(e.toString());
// 使用return后
System.out.println("finally");
System.out.println("over");
* 采用分层的思想来设计 一般不会抛出 SQLException 给调用者 而是给一个 调用者能看的懂的异常
public void method()throws /*SQLException*/NoException {
//连接数据库
//数据操作:
//throw new SQLException();
//关闭数据库
//连接数据库
//数据操作:
}catch (SQLException e) {
//会对数据库进行异常操作
//throw new SQLException();
throw new NoException();
//关闭数据库
*异常的几种格式
*记住一点:catch是用户处理异常,如果没有catch就代表异常没有被处理过,如果该异常是检测时异常,那么使用 throws必须声明.
class ExceptionStyle{
//异常的几种格式
public void method(){
//第一种格式
} catch (Exception e) {
// TODO: handle exception
//第二种格式
} catch (Exception e) {
// TODO: handle exception
//第三格式
//第四种 格式
}catch (ArithmeticException e) {
// TODO: handle exception
}catch (Exception e) {
// TODO: handle exception
//看看下面几种情况
没有throws
编译不通过
public void method1() /*throws
Exception*/{
throw new Exception();
public void method2(){
throw new Exception();
} catch (Exception e) {
// TODO: handle exception
处理一个异常后
又抛出了异常
编译不通过
public void method3(){
throw new Exception();
} catch (Exception e) {
e 被处理就可以了
public void method4(){
throw new Exception();
} catch (Exception e) {
} catch (Exception e2) {
// TODO: handle exception
没有catch 或则 throws 就是没有处理
编译 不通过 ,
public void method5(){
throw new Exception();
//关闭资源
产生的异常 有调用者处理
浏览: 588932 次
来自: 上海
谢谢了，学习了。真心有用
大神能把全套代码发来不,最近要开发这个,又是新手一枚.参考官方 ...
不错的文字啊，mybatis调用存储过程返回复杂的记录，我看了 ...
在使用注解方式的配置中，其实是比XML配置少了映射处理器是吗。 ...
太棒了 谢谢在Java中，throw与throws有什么区别？他们各自用在什么地方？_百度知道
在Java中，throw与throws有什么区别？他们各自用在什么地方？
在Java中，throw与throws有什么区别？他们各自用在什么地方？
表示遇到异常之后要抛出一个异常，声明该方法会抛出一个异常，抛给上级方法throw 是用在catch 块内的记得throws 是用在方法名之后的
其他类似问题
为您推荐：
其他4条回答
二,throws用在函数上，用逗号隔开，如果有多个异常类，后面跟异常类名，用于标示函数的异常，throw 用在函数内：函数用throw抛出异常对象，后面跟跟异常对象，通常情况是这样的上面的已经解释很详细了
我就补充两点吧 一
您好，提问者：
这里一言半句说也不清楚，请看CSDN的详细说明吧。
链接地址：
throw 用来抛出异常throws 用来标识可能抛出的异常
放在方法头用THROWS方法里面手动抛出TRHROW
java的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁throw与throws的区别，什么时候用？
[问题点数：20分，结帖人beingyourself]
throw与throws的区别，什么时候用？
[问题点数：20分，结帖人beingyourself]
不显示删除回复
显示所有回复
显示星级回复
显示得分回复
只显示楼主
本帖子已过去太久远了，不再提供回复功能。}