精华内容
下载资源
问答
  • try catch 和throw区别

    2021-01-27 20:24:17
    java里的异常多种多样,这是一种非常有用的机制,它能帮助我们处理那些我们未知的错误,在java里,关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几个的作用。 1.throw throw 就是抛出一...

    java里的异常多种多样,这是一种非常有用的机制,它能帮助我们处理那些我们未知的错误,在java里,关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几个的作用。

    1.throw
    throw 就是抛出一个异常,并获取这个异常的引用,这个异常会被抛到外部的环境,由外部环境进行处理

    class A{
    public void func() throws Exception{ throw new Exception(); } }
    这里抛出了一个Exception,Exception是throwable的子类,是所有异常的基类。与此同时,throwable还有另一个子类,也就是Error。

    这里会把Exception这个引用抛到外部环境中去处理。

    throw跟try…catch…finally的对比:

    public class ZeroTest {

       public static  void  main(String[] args) {
    
    
        try{
    
    
          int i = 100/ 0;
    
    
          System.out.print(i);
    
    
     }catch(Exception e){
    
    
          System.out.print(1);
    
    
          throw new  RuntimeException();
    
    
     }finally{
    
    
          System.out.print(2);
    
    
     }
    
    
         System.out.print(3);
    
    
     }
    

    }

     try catch是直接处理,处理完成之后程序继续往下执行,throw则是将异常抛给它的上一级处理,程序便不往下执行了。
    

    本题的catch语句块里面,打印完1之后,又抛出了一个RuntimeException,程序并没有处理它,而是直接抛出,

    因此执行完finally语句块之后,程序终止了

    首先执行try,遇到算术异常,抛出,执行catch,打印1,然后抛出RuntimeException,缓存异常,执行finally,打印2,然后抛出RuntimeException。
    如果catch中没有抛出RuntimeException,则执行结果为123。

    2.throws
    那我们就不得不说一下throws,其实throws并不是抛出一个实际的Exception而是一个异常声明,它声明这个方法可能会抛出一个异常,注意是可能,所以在没有异常的情况下也是可以用throws的,而throws本身的作用也是用来提高程序的健壮性,反过来,如果这个方法的的确确的有一个异常,那么编译器会强制让你加上throws这个异常声明。

    通常throws是写在参数列表的后面,这样就表明这个方法有可能会抛出一个异常

    class A{
    public void func() throws Exception{ throw new Exception(); } public void g() throws Exception{ } }
    3.try…catch
    当我们在其环境中调用func 和 g的时候,编译器会通知我们需要用一个Try catch程序块来处理这个异常。

    这个程序块分两块,第一块是try{} ,第二块是catch(exception的引用){}
    try这个程序块很有意思,因为它的名字很易懂,就是尝试,尝试能不能正常的走完整个作用域,如果不能则抛出一个异常。所以我们在try块里经常放上可能会抛出异常的程序段。
    而catch恰好就是处理try里抛出来的异常,其中catch的参数列表接收的是一个异常的引用,是throw抛出来的异常的引用,这样我们就可以得到这个异常的对象,倒不如说我们是得到来了这个异常对象的引用,因为在java里,通常我们也只能通过引用来操纵对象。

    PS:当 throw new RuntimeException的时候,不用throws

    public class Main {
    public static void main(String[] args){ A a = new A(); try{ a.func(); a.g(); } catch(Exception e){ System.out.println(“捕获了一个异常”); } } }
    我们捕获了func 的异常,因为我们明确的指明func 会抛出一个异常throw new Exception();所以我们这里也会捕获到,并去处理它,所以运行起来我们会看到控制台上会打印“捕获了一个异常”。

    尽管g()没有抛出任何的异常,编译器还是要求我们要用try catch把它括起来,是因为它拥有一个throws 异常说明。

    **下面是常见的几种异常,供大家参考:

    输入输出异常:IOException
    算术异常类:ArithmeticExecption
    空指针异常类:NullPointerException
    类型强制转换异常:ClassCastException

    操作数据库异常:SQLException

    文件未找到异常:FileNotFoundException
    数组负下标异常:NegativeArrayException
    数组下标越界异常:ArrayIndexOutOfBoundsException
    违背安全原则异常:SecturityException
    文件已结束异常:EOFException
    字符串转换为数字异常:NumberFormatException
    方法未找到异常:NoSuchMethodException

    展开全文
  • try ……catch和throw区别

    千次阅读 2018-06-05 11:46:52
    Trycatch…finally与直接throw区别try catch是直接处理,处理完成之后程序继续往下执行,throw则是将异常抛给它的上一级处理,程序便不往下执行了。 public class ZeroTest { public static void main...

    Try…catch…finally与直接throw的区别:try catch是直接处理,处理完成之后程序继续往下执行,throw则是将异常抛给它的上一级处理,程序便不往下执行了。

    public class ZeroTest {
        public static void main(String[] args) {
         try{
           int i = 100 / 0;
           System.out.print(i);
      }catch(Exception e){
           System.out.print(1);
           throw new RuntimeException();
      }finally{
           System.out.print(2);
      }
          System.out.print(3);
     }
     }

    所以此条程序输出12

    展开全文
  • try catch 和throw以及throws的使用

    千次阅读 2019-04-13 17:08:25
    try-catch和throw,throws的区别 java里的异常多种多样,这是一种非常有用的机制,它能帮助我们处理那些我们未知的错误,在java里,关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几个的...

    转载:https://www.cnblogs.com/zhangdaicong/p/6127984.html

    try-catch和throw,throws的区别

    java里的异常多种多样,这是一种非常有用的机制,它能帮助我们处理那些我们未知的错误,在java里,关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几个的作用。

    1.throw

    throw 就是抛出一个异常,并获取这个异常的引用,这个异常会被抛到外部的环境,由外部环境进行处理

    class A{
        public void func() throws Exception{
            throw new Exception();
        }
    }

    这里抛出了一个Exception,Exception是throwable的子类,是所有异常的基类。与此同时,throwable还有另一个子类,也就是Error。

    这里会把Exception这个引用抛到外部环境中去处理。

    throw跟try...catch...finally的对比:

     

    public class  ZeroTest {

        public static  void  main(String[] args) {

         try{

           int i = 1000;

           System.out.print(i);

      }catch(Exception e){

           System.out.print(1);

           throw new  RuntimeException();

      }finally{

           System.out.print(2);

      }

          System.out.print(3);

      }

    }

     

      try catch是直接处理,处理完成之后程序继续往下执行,throw则是将异常抛给它的上一级处理,程序便不往下执行了。

    本题的catch语句块里面,打印完1之后,又抛出了一个RuntimeException,程序并没有处理它,而是直接抛出,

    因此执行完finally语句块之后,程序终止了

     

       首先执行try,遇到算术异常,抛出,执行catch,打印1,然后抛出RuntimeException,缓存异常,执行finally,打印2,然后抛出RuntimeException。

      如果catch中没有抛出RuntimeException,则执行结果为123。

     

    2.throws

    那我们就不得不说一下throws,其实throws并不是抛出一个实际的Exception而是一个异常声明,它声明这个方法可能会抛出一个异常,注意是可能,所以在没有异常的情况下也是可以用throws的,而throws本身的作用也是用来提高程序的健壮性,反过来,如果这个方法的的确确的有一个异常,那么编译器会强制让你加上throws这个异常声明。

    通常throws是写在参数列表的后面,这样就表明这个方法有可能会抛出一个异常

    class A{
        public void func() throws Exception{
            throw new Exception();
        }
        
        public void g() throws Exception{
            
        }
    }

    3.try...catch

    当我们在其环境中调用func 和 g的时候,编译器会通知我们需要用一个Try catch程序块来处理这个异常。

    这个程序块分两块,第一块是try{} ,第二块是catch(exception的引用){}
    try这个程序块很有意思,因为它的名字很易懂,就是尝试,尝试能不能正常的走完整个作用域,如果不能则抛出一个异常。所以我们在try块里经常放上可能会抛出异常的程序段。
    而catch恰好就是处理try里抛出来的异常,其中catch的参数列表接收的是一个异常的引用,是throw抛出来的异常的引用,这样我们就可以得到这个异常的对象,倒不如说我们是得到来了这个异常对象的引用,因为在java里,通常我们也只能通过引用来操纵对象。

    PS:当 throw new RuntimeException的时候,不用throws

    public class Main {
        public static void main(String[] args){
            A a = new A();
            try{
                a.func();
                a.g();
            }
            catch(Exception e){
                System.out.println("捕获了一个异常");
            }
        }
    }

    我们捕获了func 的异常,因为我们明确的指明func 会抛出一个异常throw new Exception();所以我们这里也会捕获到,并去处理它,所以运行起来我们会看到控制台上会打印“捕获了一个异常”。

    尽管g()没有抛出任何的异常,编译器还是要求我们要用try catch把它括起来,是因为它拥有一个throws 异常说明。

     

     

    **下面是常见的几种异常,供大家参考:

    输入输出异常:IOException
    算术异常类:ArithmeticExecption
    空指针异常类:NullPointerException
    类型强制转换异常:ClassCastException

    操作数据库异常:SQLException

    文件未找到异常:FileNotFoundException
    数组负下标异常:NegativeArrayException
    数组下标越界异常:ArrayIndexOutOfBoundsException
    违背安全原则异常:SecturityException
    文件已结束异常:EOFException
    字符串转换为数字异常:NumberFormatException
    方法未找到异常:NoSuchMethodException

     

    转载:https://www.cnblogs.com/zhao307/p/5560344.html

    1:先写个简单的类:

    复制代码

    package com.exception.demo;
    
    public class Main {
        public static void main(String[] args) {
            Main main = new Main();
        }
    
        public void methodTry() {
    
        }
    
        public void methodThrow() {
    
        }
    }

    复制代码

    初始环境就是这么简答。

    2:下面给方法methodTry加上方法主体:

    复制代码

        public static void main(String[] args) {
            Main main = new Main();
            main.methodTry();
        }
    
        public void methodTry() {
            int a=10;
            int b=0;
            int c=a/b;
        }

    复制代码

    刚开始学代码的时候都会写这个方法,会抛出一个异常:

      

    控制台很清楚的告诉我们,被除数不能为0.但是如果我们想自己获取这个异常,然后做些操作呢?比如说 如果这个方法体有问题,我就做一个输出。

    复制代码

        public void methodTry() {
            try {
                int a=10;
                int b=0;
                int c=a/b;
                System.out.println(c);
            } catch (Exception e) {
                System.out.println("这个方法体有问题:"+e.getMessage());
            }
            
        }

    复制代码

    这个时候就用到了try-catch,手动的捕获这个异常,然后进行我们需要的操作。毕竟异常分很多种,并不是所有的异常都是我们不需要的。比如说对用户登录来说,登录成功 登录失败两种结果,登录失败又分为重复登录,账号密码不匹配等。我们可以把这些失败全都写成Exception。当成功的时候就直接返回,失败的时候抛出异常,这个可比我们写好多返回值简单多了。

    接着说try-catch

      

    我们手动的捕获了这个异常。上面的代码告诉我们,当try-catch块中有异常时,异常后面的代码是不会执行的。try-catch还有什么好处?回滚。

    3:throw

    复制代码

        public static void main(String[] args) {
            Main main = new Main();
            main.methodThrow();
        }
    
    
    
        public void methodThrow() {
            throw new Exception("这里有异常");
        }

    复制代码

    其实当我简单的抛出个异常的时候,throw new Exception()这里会报错,现在看一个报错信息:

      

    显示让我们选择是throws 还是try-catch。

    我们写好的throw是什么意思呢? 其实跟a/0是一个意思,都是抛出一个异常,只不过一个是jdk已经定义好的异常,被除数不能为0.一个是我们手动抛出的异常。

    先用try-catch试试看

      

    复制代码

        public void methodThrow() {
            try {
                throw new Exception("这里有异常");
            } catch (Exception e) {
                System.out.println("MethodThrow:"+e.getMessage());
            }
        }

    复制代码

      

    重点在于手动抛出异常后,我们要在catch中进行处理,在catch中写我们的部门逻辑代码。

    4:throws

    刚才我们选择的是try-catch,现在选择throws

    复制代码

        public static void main(String[] args) throws Exception {
            Main main = new Main();
            main.methodThrow();
        }
    
        public void methodThrow() throws Exception {
            throw new Exception("这里有异常");
        }

    复制代码

    方法methodThrow throws Exception之后,他的父类就面临着两种情况,要么try-catch 要么throws这个异常。这种情况跟methodThrow中手动抛出异常遇到的问题是一样的。

    看来可以这么理解:

      throw是手动抛出异常,跟 被除数不能为0 数组下标越界等异常一样,都是异常。

      try-catch是在catch中手动捕获异常,然后进行一些操作。比如说输出异常信息,打印错误日志等。

      throws是往上级抛出异常,我的方法methodThrow有异常,但是在这个方法中我不进行处理了,让上级进行处理吧。然后就跑到main函数那去了。对main函数来说,可以throws让系统进行处理,也可以自己处理这个异常啊。main.methodThrow()和a/0 、throw new Execption()没什么区别,都是有异常。

    其实可以整体的写:

    复制代码

        public static void main(String[] args){
            Main main = new Main();
            try {
                main.methodThrow();
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }
    
        public void methodThrow() throws Exception {
            throw new Exception("这里有异常");
        }

    复制代码

    方法中的异常,到main函数中再进行处理。

     

     

    总结:在程序中有异常的代码被try catch后,后边的代码能够继续执行,如果是throws 出来的,则运行到异常代码处就会停止执行,抛出异常

    展开全文
  • try-catch和throw,throws的区别 java里的异常多种多样,这是一种非常有用的机制,它能帮助我们处理那些我们未知的错误,在java里,关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几...

    try-catch和throw,throws的区别

    java里的异常多种多样,这是一种非常有用的机制,它能帮助我们处理那些我们未知的错误,在java里,关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几个的作用。

    1.throw

    throw 就是抛出一个异常,并获取这个异常的引用,这个异常会被抛到外部的环境,由外部环境进行处理

    class A{
        public void func() throws Exception{
            throw new Exception();
        }
    }

    这里抛出了一个Exception,Exception是throwable的子类,是所有异常的基类。与此同时,throwable还有另一个子类,也就是Error。

    这里会把Exception这个引用抛到外部环境中去处理。

    throw跟try...catch...finally的对比:

     

    public class  ZeroTest {
        public static  void  main(String[] args) {
         try{
           int i = 1000;
           System.out.print(i);
      }catch(Exception e){
           System.out.print(1);
           throw new  RuntimeException();
      }finally{
           System.out.print(2);
      }
          System.out.print(3);
      }
    }
     
      try catch是直接处理,处理完成之后程序继续往下执行,throw则是将异常抛给它的上一级处理,程序便不往下执行了。
    本题的catch语句块里面,打印完1之后,又抛出了一个RuntimeException,程序并没有处理它,而是直接抛出,
    因此执行完finally语句块之后,程序终止了
     
       首先执行try,遇到算术异常,抛出,执行catch,打印1,然后抛出RuntimeException,缓存异常,执行finally,打印2,然后抛出RuntimeException。
      如果catch中没有抛出RuntimeException,则执行结果为123。

     

    2.throws

    那我们就不得不说一下throws,其实throws并不是抛出一个实际的Exception而是一个异常声明,它声明这个方法可能会抛出一个异常,注意是可能,所以在没有异常的情况下也是可以用throws的,而throws本身的作用也是用来提高程序的健壮性,反过来,如果这个方法的的确确的有一个异常,那么编译器会强制让你加上throws这个异常声明。

    通常throws是写在参数列表的后面,这样就表明这个方法有可能会抛出一个异常

    class A{
        public void func() throws Exception{
            throw new Exception();
        }
        
        public void g() throws Exception{
            
        }
    }

    3.try...catch

    当我们在其环境中调用func 和 g的时候,编译器会通知我们需要用一个Try catch程序块来处理这个异常。

    这个程序块分两块,第一块是try{} ,第二块是catch(exception的引用){}
    try这个程序块很有意思,因为它的名字很易懂,就是尝试,尝试能不能正常的走完整个作用域,如果不能则抛出一个异常。所以我们在try块里经常放上可能会抛出异常的程序段。
    而catch恰好就是处理try里抛出来的异常,其中catch的参数列表接收的是一个异常的引用,是throw抛出来的异常的引用,这样我们就可以得到这个异常的对象,倒不如说我们是得到来了这个异常对象的引用,因为在java里,通常我们也只能通过引用来操纵对象。

    PS:当 throw new RuntimeException的时候,不用throws

    public class Main {
        public static void main(String[] args){
            A a = new A();
            try{
                a.func();
                a.g();
            }
            catch(Exception e){
                System.out.println("捕获了一个异常");
            }
        }
    }

    我们捕获了func 的异常,因为我们明确的指明func 会抛出一个异常throw new Exception();所以我们这里也会捕获到,并去处理它,所以运行起来我们会看到控制台上会打印“捕获了一个异常”。

    尽管g()没有抛出任何的异常,编译器还是要求我们要用try catch把它括起来,是因为它拥有一个throws 异常说明。


     

    **下面是常见的几种异常,供大家参考:

    输入输出异常:IOException
    算术异常类:ArithmeticExecption
    空指针异常类:NullPointerException
    类型强制转换异常:ClassCastException

    操作数据库异常:SQLException

    文件未找到异常:FileNotFoundException
    数组负下标异常:NegativeArrayException
    数组下标越界异常:ArrayIndexOutOfBoundsException
    违背安全原则异常:SecturityException
    文件已结束异常:EOFException
    字符串转换为数字异常:NumberFormatException
    方法未找到异常:NoSuchMethodException


    展开全文
  • try-catch和throw,throws的区别 java里的异常多种多样,这是一种非常有用的机制,它能帮助我们处理那些我们未知的错误,在java里,关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几个的...
  • try-catch和throw,throws的区别和联系

    千次阅读 2015-08-18 22:21:58
    try-catch和throw,throws的区别和联系 (2010-03-25 21:36:40)转载▼ 标签: 杂谈   区别一:throw 是语句抛出一个异常;throws 是方法抛出一个异常; throw语法:throw 在方法声明中,添加throws...
  • 这两张图可以清楚的看出来这两者之间的区别了,第一个例子中,在areturn这个指令之前,已经计算出了最后的返回值,setName是在areturn这个指令之后调用;第二个例子,就是正常执行,addSuppressed是在return之前调用...
  • throw exception try catch区别

    千次阅读 2017-08-02 09:35:55
    1. 区别throw exception直接终止方法,或者退出循环。...try catch 不中断,throw exception中断 2.代码 (1)try catch 不中断 public class ExceptionDemo { public static void main(String[]
  • java里的异常多种多样,这是一种非常有用的机制,它能帮助我们处理那些我们未知的错误,在java里,关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几个的作用。 1.throw throw 就是抛出...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 554
精华内容 221
关键字:

trycatch和throw区别