java中try语句和throw的区别
java中try语句和throw的区别
学习啦【百科知识】 编辑：映芳
　　在编程的时候往往会出现系统编译时无法检测到的错误,可是在运行时会出错,如果在可能出错的地方抛出异常,那样便严整了代码的正确性.比如数组越界,分母为0,文件等。 编程中会用try语句和throw语句来对编程运行过程中出现的异常情况进行处理。那么这两种有什么区别呢?下面小编带你去了解一下。
　　Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。
　　Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出(throws)一个异常，这时候你可以通过它的类型来捕捉(catch)它，或最后(finally)由缺省处理器来处理。
　　用try来指定一块预防所有&异常&的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的&异常&的类型。
　　throw语句用来明确地抛出一个&异常&。throws用来标明一个成员函数可能抛出的各种&异常&。
　　Finally为确保一段代码不管发生什么&异常&都被执行一段代码。可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。
　　每当遇到一个try语句，&异常&的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种&异常&进行处理，堆栈就会展开，直到遇到有处理这种&异常&的try语句。
　　try和throw的区别
　　try：出现在方法体中，它自身是一个代码块，表示尝试执行代码块的语句。如果在执行过程中有某条语句抛出异常，那么代码块后面的语句将不被执行。
　　throw：出现在方法体中，用于抛出异常。当方法在执行过程中遇到异常情况时，将异常信息封装为异常对象，然后throw。
　　补充throws和catch语句
　　throws：出现在方法的声明中，表示该方法可能会抛出的异常，允许throws后面跟着多个异常类型
　　catch：出现在try代码块的后面，自身也是一个代码块，用于捕获异常try代码块中可能抛出的异常。catch关键字后面紧接着它能捕获的异常类型，所有异常类型的子类异常也能被捕获。
　　小编举例
　　package book.
　　* 抛出异常和声明异常
　　* @author joe
　　public class ThrowAndThrows {
　　* 计算一个数字的平方根
　　* @param nStr 以字符串的形式提供数字
　　* @return 返回平方根
　　* @throws Exception 当用户输入的字符串为空，
　　* 或者字符串无法转换成数字，或者转换成的数字小于0，都会抛出异常
　　public static double sqrt(String nStr) throws Exception {
　　if (nStr == null) {
　　//用trow关键字抛出异常，当异常被抛出时，程序会跳出该方法
　　throw new Exception(&输入的字符不能为空!&);
　　double n = 0;
　　n = Double.parseDouble(nStr);
　　} catch(NumberFormatException e) {
　　//将parseDouble方法可能抛出的异常NumberFormatException捕获，
　　//然后将捕获的异常重新封装并输出
　　throw new Exception(&输入的字符串必须能够转化成数字!&, e);
　　if (n & 0 ){
　　throw new Exception(&输入的字符串转化成的数字必须大于0!&);
　　return Math.sqrt(n);
　　public static void main(String[] args) throws Exception {
　　ThrowAndThrows.sqrt(&-124.56&);
　　} catch(Exception e) {
　　//将sqrt方法声明的可能抛出的Exception异常捕获
　　//打印捕获的异常的堆栈信息，从堆栈信息中可以发现异常发生的位置和原因
　　System.out.println(&Got a Exception：& + e.getMessage());
　　e.printStackTrace();
　　 //不做进一步处理，将异常向外抛出
　　//将sqrt声明了可能会抛出的异常向外抛出，必须在方法声明中使用throws
　　ThrowAndThrows.sqrt(&-124.56&);
　　程序输出结果：
　　Got a Exception：输入的字符串转化成的数字必须大于0!
　　java.lang.Exception: 输入的字符串转化成的数字必须大于0!
　　at book.exception.ThrowAndThrows.sqrt(ThrowAndThrows.java:30)
　　at book.exception.ThrowAndThrows.main(ThrowAndThrows.java:37)
　　Exception in thread &main& java.lang.Exception: 输入的字符串转化成的数字必须大于0!
　　at book.exception.ThrowAndThrows.sqrt(ThrowAndThrows.java:30)
　　at book.exception.ThrowAndThrows.main(ThrowAndThrows.java:37)
　　源码分析：
　　在main方法里，由于sqrt方法的声明中有throws关键字，所以，在调用该方法时，必须对throws后面声明的异常进行处置，处置的方法有两种：
　　(1)main方法处理该异常，使用try.....catch语句，将可能会出现的异常的代码放在try块内，将处理异常的代码放在catch块内，并指明catch能够捕获的异常的类型，当异常被捕获时，执行catch块内的语句。
　　(2)main方法不处理该异常，将异常向外层程序抛出。在方法声明中使用throws关键字抛出异常，方法体中不需要使用try...catch语句。
　　异常类Exception的getMessage方法用来获取一场的描述信息，printStackTrace方法用来打印异常的堆栈信息，通过堆栈信息能够查明异常发生的原因和位置，在调试的时候常用。
本文已影响 人
[java中try语句和throw的区别]相关的文章
看过本文的人还看了
1945人看了觉得好
5188人看了觉得好
703人看了觉得好
【百科知识】图文推荐
Copyright & 2006 -
All Rights Reserved
学习啦 版权所有Java中throws和throw的区别讲解_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
Java中throws和throw的区别讲解
||文档简介
北大青鸟IT培训|
总评分0.0|
&&J​a​v​a​中​t​h​r​o​w​s​和​t​h​r​o​w​的​区​别​讲​解
阅读已结束，如果下载本文需要使用0下载券
想免费下载更多文档？
定制HR最喜欢的简历
你可能喜欢-----------、、java学习型技术博客、期待与您交流！&-----------
//throws与throw的区别：
public class throwandthrows {
public static int check(String strage) throws Exception{
int age = Integer.parseInt(strage);
if(age & 0){
throw new Exception(&年龄不能为负数！&);
/*毕向东老师的Java基础视频讲解throws和throw的区别：
&(1)throws使用在函数上
& & &throw 使用在函数内
&(2)throws后面跟的异常类，可以多个，用逗号隔开。
& & & throw 后面跟的异常对象。
/*下面是我的总结
& (1)throws关键字通常在声明类方法中使用,格式是类方法定义时在方法名后写throws&异常类&。
& & & & & throw关键字通常是在方法体中使用,格式是在可能出现错误的模块中写throw &异常对象&。
& (2)throws:当调用方法时，如果发生异常，就会将异常抛给指定的异常对象。
& & & & &throw：程序在执行到throw语句时立即停止，它后面的语句都不执行。
& (3)有throws的时候可以没有throw。
& & & &有throw的时候如果throw抛的异常时Exception体系，必须有throws在方法上声明。如果是RuntimeException则不用声明，为了让它在运行时出问题然后我们修改代码。
& (4)throws用于方法的声明上，其后跟的是异常类名，后面可以跟多个异常类，之间用逗号隔开，throw用于方法体中，其后跟的是一个异常对象名。
-----------、、java学习型技术博客、期待与您交流！&-----------
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：3437次
排名：千里之外
原创：13篇java中抛出异常throw和throws有什么区别-中国学网-中国IT综合门户网站-提供健康,养生,留学,移民,创业,汽车等信息
> 信息中心 >
java中抛出异常throw和throws有什么区别
来源：互联网 发表时间： 10:42:41 责任编辑：鲁晓倩字体：
为了帮助网友解决“java中抛出异常throw和throws有什么区别”相关的问题，中国学网通过互联网对“java中抛出异常throw和throws有什么区别”相关的解决方案进行了整理,用户详细问题包括:RT,我想知道:java中抛出异常throw和throws有什么区别，具体解决方案如下：解决方案1： 有些程序中编译是没有问题的.但它存在着逻辑的异常.比如说零做除数.当有这样的情况时,你可以通过IF来处理,你也可以能过异常,也就是说如果零做除数你就用throw new Exception()抛出一个异常.!
然后能过try-catch来处理.如果说你抛出的异常写在的是方法里,并且你没有用try-catch来处理,那么你就需要在方法的()后面用throws来向上一层抛出异常.当你调用这个方法的时候再进行try-catch处理 解决方案2： 1.throws 用于抛出方法层次的异常， 
并且直接由些方法调用异常处理类来处理该异常， 
所以它常用在方法的后面。比如 
public static void main(String[] args) throws SQLException 

2.throw 用于方法块里面的代码，比throws的层次要低，比如try...catch ....语句块，表示它抛出异常， 
但它不会处理它， 
而是由方法块的throws Exception来调用异常处理类来处理。
相关文章：
最新添加资讯
24小时热门资讯
Copyright © 2004- All Rights Reserved. 中国学网 版权所有
京ICP备号-1 京公网安备02号JAVA基础学习之throws和throw的区别、Java中的四种权限、多线程的使用等（2） - szyuxueliang - 推酷
JAVA基础学习之throws和throw的区别、Java中的四种权限、多线程的使用等（2） - szyuxueliang
throws使用在函数外，是编译时的异常，throw使用在函数内，是运行时的异常
public int method(int[] arr) throws NullPointerException{}
public int method(int[] arr){
if(arr==null){
throw new NullPointerException (“数组的引用不能为空”);
throws 抛出的是异常类，可以抛出多个，用逗号隔开，throw抛出的是异常对象
中的四种权限
public protected default private，其中如果什么都没有写，就是default
３．多线程
多线程的好处：解决了多个程序同时运行的问题。
多线程的弊端：线程太多会导致效率降低
其实应用程序的执行都是CPU在做着快速的切换完成的。这个切换是随机的
java中运行垃圾回收是：System.gc();
创建线程方式一并使用
代码如下：
package com.itcast.
* 创建线程方式
* 1.子类继承Thread类，子类覆盖父类中的run方法，将线程要执行的代码写在run方法中
* 2.建立子类对象的同时线程也被创建
* 3.通过调用start方法开启线程
* @author yxl
public class ThreadSub extends Thread {
public void run() {
// 这里面是线程要执行的代码
for (int i = 0; i & 10; i++) {
System.out.println(i+&---&+Thread.currentThread().getName());
public ThreadSub(String threadName){
package com.itcast.
public class Demo {
public static void main(String[] args) {
//创建线程并调用第一种方式
ThreadSub threadSub = new ThreadSub(&线程1&);
ThreadSub threadSub2 = new ThreadSub(&线程2&);
threadSub.start();// 开启线程，调用run方法
// threadSub.run();如果直接调用run（）方法就是只调用主线程执行
threadSub2.start();
创建线程方式二推荐使用这种方式
代码如下：
package com.itcast.
* 创建线程的第二种方式，实现Runnable接口。推荐使用这种方式
* 1.定义类实现Runnable接口
* 2.覆盖接口中的run方法，并将线程的任务代码封装到run方法中
* 3.通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数
* 的参数进行传递，通过对象调用run方法
* 4.调用线程对象的start（）开启线程
* @author yxl
public class ImplementThread implements Runnable {
public void run() {
// 这里面是线程要执行的代码
for (int i = 0; i & 10; i++) {
System.out.println(i+&---&+Thread.currentThread().getName());
package com.itcast.
public class Demo {
public static void main(String[] args) {
//创建线程并调用第二种方式，推荐使用第二种方式
ImplementThread thread = new ImplementThread();
Thread t =new Thread(thread);
t.start();
Thread t2 =new Thread(thread);
t2.start();
同步解决线程安全问题（JDK1.5之前版本使用的方式）
Object object = new Object();
synchronized (object) {
&&&&&&&&&&&&&&&&&&&&&&&&&&&
相当于lock锁
* 同步函数
* 同步函数使用的锁是this，建议使用同步代码块锁
public synchronized void Show() {
&&&&&&&&&&&&&&&&&&
线程间通讯：
多个线程在处理同一资源，但是任务却不同。
生产者消费者模式：
代码如下：&&&&&&
package com.itcast.test1;
import java.util.concurrent.locks.C
import java.util.concurrent.locks.L
import java.util.concurrent.locks.ReentrantL
* 等待唤醒机制
* 1.wait（）：让线程处于冻结状态，被wait的线程会被存储到线程池中
* 2.notify（）：唤醒线程池中一个线程（任意）
* 3.notifyAll（）：唤醒线程池中的所有线程。
* 这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法，必须要明确到底操作的是哪个锁上的线程。
* 以上方法都是定义在Object类中，因为这些方法是监视器的方法，监视器其实就是锁
* jdk1.5以后将同步和锁封装成了对象，并将操作锁的隐士动作变成了显示动作 。
* Lock接口：出现替代了同步代码块或者同步函数。将同步的隐士锁操作变成现实锁操作，同时更为灵活，可以一个锁上加上多组监视器
* lock():获取锁，unlock（）：释放锁，通常需要定义在finally代码块中。
* Condition接口：出现替代了Object中的wait notify notifyAll方法，将这些监视器方法单独进行了封装，
* 变成Condition监视器对象。可以任意锁进行组合。
* signal()
* signalAll()
* 生产资源类
* @author yxl
public class Resourse {
public boolean flag = false;// 用来标识用的，为了实现生产一个，消费一个,为true，表示生产者有数据
Lock lock = new ReentrantLock();
Condition conditionProductor = lock.newCondition();
Condition conditionCustomer = lock.newCondition();
int count = 0;
public String getName() {
public void setName(String name) {
this.name =
public void set(String name) {
lock.lock();
while (flag) {
conditionProductor.await();
setName(name+count);
System.out.println(Thread.currentThread().getName()+&-----&+getName());
flag = true;
conditionCustomer.signal();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
lock.unlock();
public void out(){
lock.lock();
while (!flag) {
conditionCustomer.await();
System.out.println(Thread.currentThread().getName()+&-----&+name);
flag = false;
conditionProductor.signal();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
lock.unlock();
package com.itcast.test1;
* 生产者类
* @author yxl
public class Productor implements Runnable {
public Productor(Resourse resourse){
this.resourse =
public void run() {
while(true){
resourse.set(&生产者名称&);
package com.itcast.test1;
* 消费者类
* @author yxl
public class Customer implements Runnable {
public Customer(Resourse resourse){
this.resourse =
public void run() {
while(true){
resourse.out();
package com.itcast.test1;
public class MainDemo {
public static void main(String[] args) {
Resourse resourse = new Resourse();
Productor productor = new Productor(resourse);
Customer customer = new Customer(resourse);
Thread thread1 = new Thread(productor);
thread1.start();
Thread thread2 = new Thread(customer);
thread2.start();
Thread thread3 = new Thread(productor);
thread3.start();
Thread thread4 = new Thread(customer);
thread4.start();
wait和sleep的区别：
1.wait可以指定时间也可以不指定，sleep必须指定时间
2.在同步中，对CPU的执行权和锁的处理方式不同
wait释放执行权，释放锁，sleep释放执行权，不释放锁，因为它一定有时间的限制，不需要释放锁。
终止线程的方法：
1.可以使用interrupt（）方法将线程从冻结状态强制恢复到运行状态中来，让线程具备CUP的执行资格。当然强制动作会发生InterruptedException，记得要处理，在异常处理中使用标记来终止线程
2.也可以使用thread2.setDaemon(true);将线程设置为守护线程，也就是后台线程，所有前台线程都结束，后台线程自动结束
代码如下：
package com.itcast.test2;
public class StopThread implements Runnable {
private boolean flag = true;
public synchronized void run() {
while(flag){
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName());
//出错的时候，可以设置标记
flag = false;
System.out.println(Thread.currentThread().getName());
package com.itcast.test2;
public class MainDemo {
public static void main(String[] args) {
StopThread stopThread = new StopThread();
Thread thread = new Thread(stopThread);
thread.start();
thread.setPriority(Thread.MAX_PRIORITY);//设置线程的优先级,值为1-10
Thread thread1 = new Thread(stopThread);
thread1.start();
Thread thread2 = new Thread(stopThread);
thread2.setDaemon(true);//第二种终止线程的方法，将线程设置为守护线程，也就是后台线程
//所有前台线程都结束，后台线程自动结束
thread2.start();
for (int i = 0; i & 100; i++) {
if (i==58) {
thread.interrupt();//调用interrupt（）方法终止线程
thread1.interrupt();
System.out.println(i);
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致}