精华内容
下载资源
问答
  • 异常处理关键字 Java异常处理机制用到的几个关键字:try、catch、finally、throw、throws。 try:用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内,当try语句块内发生异常时,异常就被抛出。 ...

    Java工程师知识树 / Java基础


    异常处理关键字

    Java异常处理机制用到的几个关键字:try、catch、finally、throw、throws。

    • try:用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内,当try语句块内发生异常时,异常就被抛出。
    • catch:用于捕获异常。catch用来捕获try语句块中发生的异常。
    • finally:finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块,执行完成之后,才会回来执行try或者catch块中的return或者throw语句,如果finally中使用了return或者throw等终止方法的语句,则就不会跳回执行,直接停止。
    • throw:用于抛出异常。
    • throws:用在方法签名中,用于声明该方法可能抛出的异常。

    final、finally、finalize的区别与用法

    final: 用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承。
    finally: 是异常处理语句结构的一部分,表示总是执行。
    finalize: 是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,供垃圾收集时的其他资源回收,例如关闭文件等。

    Try-with-resources

    环境

    Java1.7版本及其以后版本

    语法

    JDK1.7开始,java引入了 try-with-resources 声明,将 try-catch-finally 简化为 try-catch,这其实是一种语法糖,在编译时会进行转化为 try-catch-finally 语句。
    新的声明包含三部分:try-with-resources 声明try 块catch 块。它要求在 try-with-resources 声明中定义的变量实现了 AutoCloseable 接口,这样在系统可以自动调用它们的close方法,从而替代了finally中关闭资源的功能。

    所有实现了 java.lang.AutoCloseable接口(其中,它包括实现了java.io.Closeable 的所有对象),可以使用作为资源。

    try-with-resources 声明在 JDK 9 得到改进。如果你已经有一个资源是 final 或等效于 final 变量,您可以在try-with-resources语句中使用该变量,而无需在try-with-resources语句中声明一个新变量。

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.Reader;
    import java.io.StringReader;
     
    public class Tester {
       public static void main(String[] args) throws IOException {
          System.out.println(readData("test"));
       } 
       static String readData(String message) throws IOException {
          Reader inputString = new StringReader(message);
          BufferedReader br = new BufferedReader(inputString);
          try (br) {//在 Java 9 中,不需要声明资源 br就可以使用它,并得到相同的结果。
             return br.readLine();
          }
       }
    }
    

    作用

    关闭在try-catch语句块中使用的资源,需要在ry-with-resources 声明中的实现AutoCloseable 接口的资源。

    使用范例

    Java1.7之前写法

    public static void main(String[] args) {
        FileInputStream file = null;
        try {
            file = new FileInputStream("D:\\logs\\log-cleaner.log");
            System.out.println("ooo");
            file.read();
            System.out.println("aaa");
        } catch (IOException io) {
            System.out.println("bbb");
            io.printStackTrace();
        } catch (Exception e) {
            System.out.println("ccc");
            e.printStackTrace();
        } finally {
            if (file != null) {
                try {
                    file.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    使用JDK1.9之前的 try-with-resources异常处理机制

    public static void main(String[] args) {
        try(FileInputStream file = new FileInputStream("D:\\logs\\log-cleaner.log")){
            System.out.println("ooo");
            file.read();
            System.out.println("aaa");
        }catch (IOException io){
            System.out.println("bbb");
            io.printStackTrace();
        }catch (Exception e){
            System.out.println("ccc");
            e.printStackTrace();
        }
    }
    

    编译后的class文件

    public static void main(String[] paramArrayOfString)
    {
        try
        {
            FileInputStream localFileInputStream = new FileInputStream("D:\\logs\\log-cleaner.log"); 
            Object localObject1 = null;
            try { 
                System.out.println("ooo");
                localFileInputStream.read();
                System.out.println("aaa");
            }
            catch (Throwable localThrowable2)
            {
                localObject1 = localThrowable2; throw localThrowable2;
            }
            finally
            {
                if (localFileInputStream != null) if (localObject1 != null) try { localFileInputStream.close(); } catch (Throwable localThrowable3) { localObject1.addSuppressed(localThrowable3); } else localFileInputStream.close();
            }
        } catch (IOException localIOException) {
            System.out.println("bbb");
            localIOException.printStackTrace();
        } catch (Exception localException) {
            System.out.println("ccc");
            localException.printStackTrace();
        }
    }
    

    return与finally的执行顺序

    public class TestException {
    
    
        public static void main(String[] args) {
            System.out.println("-------------");
            System.out.println(div());//try中有return,且try中不抛异常。
            /*结果:
            process try
            process finally
            0
             */
            System.out.println("-------------");
            System.out.println(divE());//catch中有return,且try中抛异常。
            /*结果:
            process try
            process catch
            process finally
            2
             */
            System.out.println("-------------");
            System.out.println(divEr());//catch,finally中都有return,且try中抛异常。
            /*
            process try
            process catch
            process finally
            3
             */
        }
        public static int div() {
            int result = 0;
            try {
                System.out.println("process try");
                return result;//如果try和catch的return是一个变量时且函数的是从其中一个返回时,后面finally中语句即使有对返回的变量进行赋值的操作时,也不会影响返回的值。
            } catch (ArithmeticException e) {
                result = 2;
                System.out.println("process catch");//
            } finally {
                result = 3;//finally中语句对返回的变量进行赋值的操作时,也不会影响返回的值
                System.out.println("process finally");//
            }
            return result;
        }
        public static int divE() {
            int result = 0;
            try {
                System.out.println("process try");
                int proces = 1/0;
                return result;
            } catch (ArithmeticException e) {
                result = 2;
                System.out.println("process catch");
                return result;//如果try和catch的return是一个变量时且函数的是从其中一个返回时,后面finally中语句即使有对返回的变量进行赋值的操作时,也不会影响返回的值。
            } finally {
                result = 3;//finally中语句对返回的变量进行赋值的操作时,也不会影响返回的值
                System.out.println("process finally");
            }
        }
    
        public static int divEr() {
            int result = 0;
            try {
                System.out.println("process try");
                result = 1/0;
                return result;
            } catch (ArithmeticException e) {
                result = 2;
                System.out.println("process catch");
    //            throw new ArithmeticException("divEr执行异常");// finally 里有return,这里throw失效
                return result;// finally 里有return,这里return失效
            } finally {
                result = 3;
                System.out.println("process finally");
                return result;//finally块中的return语句会阻止异常的栈调用传输,使divEr认为该方法已经正常返回
            }
        }
    
    }
    

    通过上面代码可以得出结论:

    • 当finally有返回值时,会直接返回。不会再去返回try或者catch中的返回值。
    • 如果try和catch的return是一个变量时且函数的是从其中一个返回时,后面finally中语句即使有对返回的变量进行赋值的操作时,也不会影响返回的值。

    原因通过反编译插件查看Class文件:

    展开全文
  • 请说明JAVA语言如何进行异常处理关键字:throws,throw,try,catch,finally分别代表什么意义?在try块中可以抛出异常吗? Java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的接口。 在...

    请说明JAVA语言如何进行异常处理,关键字:throws,throw,try,catch,finally分别代表什么意义?在try块中可以抛出异常吗?

    Java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的接口。
    在Java中,每个异常都是一个对象,它是Throwable类或其子类的实例。当一个方法出现异常后便抛出一个异常对象,该对象中包含有异常信息,调用这个对象的方法可以捕获到这个异常并可以对其进行处理。

    Java 的异常处理是通过 5 个关键词来实现的:try、catch、throw、throws 和 finally。
    一般情况下是用 try 来执行一段程序,如果出现异常,系统会抛出(throws)一个异常,这时候你可以通过它的类型来捕捉(catch)它,或最后(finally)由缺省处理器来处理;

    try 用来指定一块预防所有“异常”的程序;
    catch 子句紧跟在 try 块后面,用来指定你想要捕捉的“异常”的类型;
    throw 语句用来明确地抛出一个“异常”;
    throws 用来标明一个成员函数可能抛出的各种“异常”;
    Finally 为确保一段代码不管发生什么“异常”都被执行一段代码;

    可以在一个成员函数调用的外面写一个 try 语句,在这个成员函数内部写另一个 try 语句保护其他代码。每当遇到一个 try 语句,“异常”的框架就放到堆栈上面,直到所有的 try 语句都完成。如果下一级的 try 语句没有对某种“异常”进行处理,堆栈就会展开,直到遇到有处理这种“异常”的 try 语句。

    class Demo{
    public static void main(String[] args){
        try{
            ...
        }catch{
            ...
        }finally{
            ...
        }        
    }
    
    class Demo{
    public static void main(String[] args) throws Exception{
        ...
    }
    
    展开全文
  • public int div(int i,int j)throws Exception{ //throws Exception声明的方法不对此类异常进行处理,而由该方法的调用者负责处理 int temp=i/j; return temp; } } public class sev...

     

    throws关键字

    class Math{
        public int div(int i,int j)throws Exception{   //throws Exception声明的方法不对此类异常进行处理,而由该方法的调用者负责处理
            int temp=i/j;
            return temp;
        }
    }
    public class seven4{
        public static void main(String[] args){
            Math m=new Math();
            try{
                System.out.println("除法操作:"+m.div(10,2)); 
            }
            catch(Exception e){
                e.printStackTrace();    //打印异常
            }
        }
    }

    throw关键字

    java中还可以直接使用throw关键字人为抛出一个异常,人工抛出异常的格式:

      throw 异常类对象;    ---被抛出的必须是Throwable或其子类对象

         IOException e=new IOException();

         throw e;      

       程序执行throw语句后立即终止,然后在包含它的所有try块中从里向外寻找含有与其类型匹配的catch子句。

    public class ThrowDemo1{
        public static void main(String args[]){
            try{
                throw new Exception("自己抛着玩的。") ;    //抛出时直接抛出异常实例化对象即可
    
            }catch(Exception e){
                System.out.println(e) ;
            }
        }
    }

    自定义异常类

    虽然Java的内置异常处理能够处理大多数常见错误,但用户仍需建立自己的异常类型来处理特殊情况。这时可以通过创建Exception的子类来定义自己的异常类。

    格式:class 类名 extends Exception{

         … …

         }

    class MyException extends Exception{
        MyException(String str){  //在定义异常类时一般需要定义构造方法接收异常信息,该信息可由父类的构造方法传入。
            super(msg);
        }
    }

     

    系统定义的异常,在程序中遇到时是由系统自动抛出的,但是 在抛出自定义异常时,需要用户使用throw语句自己抛出,其格式 如下:

        throw new 自定义的异常类类名([参数列表]);

    class MyException extends Exception{    
        public MyException(String msg){
            super(msg) ;    
        }
    }
    public class DefaultException{    
        public static void main(String args[]){
            try{
                throw new MyException("自定义异常。") ;     
            }catch(Exception e){
                System.out.println(e) ;
            }
        }
    }

     

    转载于:https://www.cnblogs.com/l666/p/9657399.html

    展开全文
  • throws是获取异常 throw是抛出异常 ...try是将会发生异常的语句括起来,从而进行异常处理,也可以在try块中抛出新的异常 catch是如果有异常就会执行他里面的语句 finally不论是否有异常都会进行执行的语句

    throws是获取异常
    throw是抛出异常
    try是将会发生异常的语句括起来,从而进行异常的处理,也可以在try块中抛出新的异常
    catch是如果有异常就会执行他里面的语句
    finally不论是否有异常都会进行执行的语句
    在这里插入图片描述

    展开全文
  • trows捕获并向外抛出异常 trow抛出异常 try catch是内部捕获异常并做自定义处理 finally是无论是否有异常都会被处理的语句,除非在finally前存在被执行的system.exit(int i)时除外。
  • 问:异常处理关键字的作用和处理流程Java的异常处理主要通过try、catch、finally关键字来实现。try关键字对紧随其后一队花括号括起来的代码块(try代码块)进行异常扑捉,如果出现异常就跳转到catch模块。catch关键字...
  • 异常 throws关键字

    2020-01-11 17:16:59
    throws关键字异常处理的第一种方式,交给别人处理 作用 当方法内部抛出异常对象的时候,那么我们就必须处理异常对象 可以使用throws关键字处理异常对象,把异常对象抛出声明抛出给声明的调用者处理。(自己部处理,...
  • java异常处理常用关键字

    千次阅读 2019-08-06 20:04:39
    异常处理两种方式: 1、捕获异常...异常处理的5 个关键字: try, catch, finally throw, throws 捕获异常时,:先捕获小异常再捕获大异常 异常处理格式 try{ //可能出异常的代码 }catch(异常类 对象){ //处...
  • 异常处理throws关键字

    2009-11-25 22:44:09
    hrows关键字通常被应用在声明方法时,用来指定可能抛出的异常,throws 用于抛出方法层次的异常,并且直接由些方法调用异常处理类来处理该异常
  • 主要介绍了Java异常处理与throws关键字用法,结合实例形式分析了java常见的异常、错误处理及throws关键字相关使用技巧、注意事项,需要的朋友可以参考下
  • Java异常throw关键字

    2021-06-04 00:02:35
    可以使用throw关键字在指定的方法中抛出指定的异常 使用格式: throw new xxxException("异常产生的原因"); 注意: 1.throw关键字必须写在方法的内部 2.throw关键字后边new的对象必须是Exception或者Exception的...
  • 什么是异常   异常是程序中的一些错误,但...异常处理格式 try{ //有可能出现异常的语句 }catch(异常类 异常对象){ //编写异常处理的语句 }【catch(异常类 异常对象){ //编写异常处理的语句 }catch(...
  • C++ 的异常处理 中包括: 1. throw 表达式,错误检测部分使用这种表达式来说明遇到了不可处理的错 误。可以说,throw 引发了异常条件。 2. try 块,错误处理部分使用它来处理异常。try 语句块以 try 关键字开 ...
  • Java中异常以及关键字

    2020-07-19 23:12:06
    二、异常的五大关键字 1.try:存放可能发生异常的代码块 2.catch:捕获并处理异常 3.finally:无论如何都要执行的代码,除非jvm退出 4.throws:声明异常,将方法可能发生的异常列举出来 5.throw:抛出异常,自定义...
  • 本篇文章给大家详细讲述了关于Java异常处理的相关知识点,并列举了5个重要关键字,一起啊参考学下。
  • C#的异常处理之Throw关键字
  • Java 异常 throws关键字

    2019-09-19 18:24:32
    异常格式: try{ 异常语句 }catch(Exception e){ //Exception为异常类型,如果清楚会抛出的异常可直接指定类型 }finally{ 一定执行的语句 } 常见的异常类型: NullPointerException 空指针异常 ArithmeticExcep...
  • 主要介绍了java处理异常的机制关键字throw和throws使用解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 1.在定义一个方法的时候可以使用throws关键字声明,使用throws声明的方法表示此方法不处理异常,抛给方法的调用者处理。 2.格式:  public void tell()throws Exception{} 例子: public static void ...
  • Java中处理异常中return关键字
  • 抛出异常throws关键字的应用

    千次阅读 2016-09-30 15:58:04
    throws关键字通常被应用在声明方法时,用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时,如果发生异常,就会 将异常抛给指定异常对象。如下面例子所示:
  • 工程师培训资料 标题Java培训系列课程-throws关键字精品培训 培训人xx 本章学习目标 了解异常的产生原理 掌握异常处理语句的基本格式 掌握throwthrows关键字的作用 可以自定义异常 了解Exception与RuntimeException...
  • 主要介绍了java处理异常2种机制关键字区别解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • catch: 在您想要处理问题的地方,通过异常处理程序捕获异常。catch 关键字用于捕获异常。 try: try 块中的代码标识将被激活的特定异常。 注:1.catch 块跟在 try 块后面,用于捕获异常。您可以指定想要捕捉的异常...
  • Java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的接口。 在Java中,每个异常都是一个对象,它是Throwable类或其子类的实例。当一个方法出现异常后便抛出一个异常对象,该对象中包含有...
  • 异常处理常用一下3个函数来获取异常信息 e.getMessage()函数:输出错误性质 e.toString()函数:给出异常的类型与性质 printStackTrace()函数:指出异常的性质、类型、以及出现在程序中的位置。 finally语句块 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 263,325
精华内容 105,330
关键字:

属于异常处理的关键字