精华内容
下载资源
问答
  • 本篇文章给大家详细讲述了关于Java异常处理的相关知识点,并列举了5个重要关键字,一起啊参考学下。
  • 异常处理关键字 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的异常处理主要通过try、catch、finally关键字来实现。try关键字对紧随其后一队花括号括起来的代码块(try代码块)进行异常扑捉,如果出现异常就跳转到catch模块。catch关键字...

    问:异常处理关键字的作用和处理流程Java的异常处理主要通过try、catch、finally关键字来实现。try关键字对紧随其后一队花括号括起来的代码块(try代码块)进行异常扑捉,如果出现异常就跳转到catch模块。catch关键字可以出现多次,每个catch关键后会面紧随一个处理异常的代码块来处理try代码块中出现的异常。finally关键字用于回收再try块中使用的物理资源,如文件打开并操作后,必须要关闭。Finally块不管出不出现异常,总会被执行。( )

    A:错,B:对

    正确答案:绛旓細浠峰€兼€?鏂伴鎬?鐪熷疄鎬?

    绛旓細淇℃伅

    解析:

    问:异常处理关键字的作用和处理流程Java的异常处理主要通过try、catch、finally关键字来实现。try关键字对紧随其后一队花括号括起来的代码块(try代码块)进行异常扑捉,如果出现异常就跳转到catch模块。catch关键字可以出现多次,每个catch关键后会面紧随一个处理异常的代码块来处理try代码块中出现的异常。finally关键字用于回收再try块中使用的物理资源,如文件打开并操作后,必须要关闭。Finally块不管出不出现异常,总会被执行。( )A:错,B:对

    相关问题:

    摘要和正文是完全独立的

    A:错B:对

    “前Web时代”,互联网的终端连接之间采用的哪种结构?( )

    A:中心式B:交叉式C:分布式D:包交换

    《左传》所载"在肓之上,膏之下,攻之不可,达之不及……","攻"是指( )

    A:灸法B:服药C:推拿D:针刺

    商代的乐器很多是从单件到多件发展的。

    A:错B:对

    下列选项属于F和声大调的特性音级的是(     )

    A:EB:bDC:#ED:D

    山西境内的下列哪些河流属于黄河支流?

    A:汾河B:偏关河C:桑干河D:沁河

    以操作机械设备为主的岗位,应采用(  )进行工作分析。

    A:调查问卷法B:工作日志法C:现场观察法D:典型事件法

    公共部门管理与私人部门管理有相似性,本质上没有太大差异。( )

    A:对,B:错

    明经科的地位最初高于进士科,(     )时期,进士科的地位就超过了明经科。

    A:唐宣宗B:唐太宗C:唐玄宗D:唐高宗

    展开全文
  • 异常处理关键字:try、catch、finally、throw、throws注意事项:1、错误不是异常,而是脱离程序员控制的问题。2、所有的异常类是从 java.lang.Exception 类继承的子类。3、异常类有两个主要的子类:IOException 类和...

    3d05d5792e909b28196debcb95ee9b3d.png

    什么是异常?

    异常有的是因为用户错误引起,有的是程序错误引起的,还有其它一些是因为物理错误引起的。

    异常处理关键字:

    try、catch、finally、throw、throws

    注意事项:

    1、错误不是异常,而是脱离程序员控制的问题。

    2、所有的异常类是从 java.lang.Exception 类继承的子类。

    3、异常类有两个主要的子类:IOException 类和 RuntimeException 类。

    4、Java有很多的内置异常类。

    (视频教程推荐:java视频)

    语法:try{

    //需要监听的代码块

    }

    catch(异常类型 异常名称/e){

    //对捕获到try监听到的出错的代码块进行处理

    throw 异常名称/e; //thorw表示抛出异常

    throw new 异常类型(“自定义”);

    }

    finally{

    //finally块里的语句不管异常是否出现,都会被执行

    }

    修饰符 返回值 方法名 () throws 异常类型{

    //throws只是用来声明异常,是否抛出由方法调用者决定

    //代码块

    }

    示例代码:(try与catch与finally)public class ExceptionTest {

    public static void main(String[] args) {

    Scanner input=new Scanner(System.in);

    try{ //监听代码块

    int a=input.nextInt();

    int b=input.nextInt();

    double sum=a/b;

    System.out.println(sum);

    }

    catch(InputMismatchException e){

    System.out.println("只能输入数字");

    }

    catch(ArithmeticException e){

    System.out.println("分母不能为0");

    }

    catch(Exception e){ //Exception是所有异常的父类

    System.out.println("发生了其他异常");

    }

    finally{ //不管是否出现异常,finally一定会被执行

    System.out.println("程序结束");

    }

    }

    }

    示例代码:(throw关键字)import java.util.InputMismatchException;

    import java.util.Scanner;

    public class ExceptionTest {

    public static void main(String[] args) {

    Scanner input=new Scanner(System.in);

    try{ //监听代码块

    int a=input.nextInt();

    int b=input.nextInt();

    double sum=a/b;

    System.out.println(sum);

    }

    catch(InputMismatchException e){ //catch(异常类型 异常名称)

    System.out.println("只能输入数字");

    throw e; //抛出catch捕捉到的异常

    //throw new InputMismatchException(); 同上

    }

    catch(ArithmeticException e){

    System.out.println("分母不能为0");

    throw new ArithmeticException("分母为0抛出异常"); //抛出ArithmeticException异常

    }

    catch(Exception e){ //Exception是所有异常的父类

    System.out.println("发生了其他异常");

    }

    finally{ //不管是否出现异常,finally一定会被执行

    System.out.println("程序结束");

    }

    }

    }

    示例代码:(throws)public class Throws {

    int a=1;

    int b=0;

    public void out() throws ArithmeticException{ //声明可能要抛出的异常,可以有多个异常,逗号隔开

    try{ //监听代码块

    int sum=a/b;

    System.out.println(sum);

    }

    catch(ArithmeticException e){

    System.out.println("分母不能为0");

    }

    finally{ //不管是否出现异常,finally一定会被执行

    System.out.println("程序结束");

    }

    }

    public static void main(String[] args){

    Throws t=new Throws();

    t.out(); //调用方法

    throw new ArithmeticException("分母为0抛出异常"); //由调用的方法决定是否要抛出异常

    /*

    * 第二种抛出方式

    */

    //ArithmeticException a=new ArithmeticException("分母为0抛出异常");

    //throw a;

    }

    }

    展开全文
  • java异常处理中使用了四个关键字。throw:有时我们明确要创建异常对象然后抛出它来停止程序的正常处理。throw关键字用于向运行时抛出异常来处理它。throws:当我们在方法中抛出任何已检查的异常而不处理它时,我们...

    java异常处理中使用了四个关键字。

    throw:有时我们明确要创建异常对象然后抛出它来停止程序的正常处理。throw关键字用于向运行时抛出异常来处理它。

    23657cbbc569e3e035371a17810b829c.png

    throws:当我们在方法中抛出任何已检查的异常而不处理它时,我们需要在方法签名中使用throws关键字让调用者程序知道该方法可能抛出的异常。调用方法可以处理这些异常或使用throws关键字将其传播给它的调用方法。我们可以在throws子句中提供多个异常,也可以与main()方法一起使用。

    try-catch:我们在代码中使用try-catch块进行异常处理。try是块的开始,catch是在try块的末尾处理异常。我们可以使用try有多个catch块,try-catch块也可以嵌套。catch块需要一个应该是Exception类型的参数。

    finally:finally块是可选的,只能用于try-catch块。由于异常会暂停执行过程,因此我们可能会打开一些不会关闭的资源,因此我们可以使用finally块。finally块总是被执行,无论是否发生异常。

    本篇文章是由武汉java培训为您呈现,希望给您带来更多更好的文章!

    展开全文
  • 请说明JAVA语言如何进行异常处理关键字:throws,throw,try,catch,finally分别代表什么意义?在try块中可以抛出异常吗? Java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的接口。 在...
  • throws是获取异常 throw是抛出异常 ...try是将会发生异常的语句括起来,从而进行异常处理,也可以在try块中抛出新的异常 catch是如果有异常就会执行他里面的语句 finally不论是否有异常都会进行执行的语句
  • Java异常处理总结

    2021-03-07 21:33:39
    一、异常概述异常指的是在程序运行中出现的错误,在程序执行期间发生的时间,它中断了正在执行的程序的正常...image.png我们可以通过异常处理机制,可以将非正常情况下的处理代码与程序的主逻辑分离,即在编写代码...
  • java异常处理常用关键字

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

    千次阅读 2018-09-16 14:13:40
    首先来个总的图,了解一下Java异常类的结构层次图  Throwable:Java中所有的异常都有共同的父类Throwable(可抛出)。它有两个重要的子类Error(错误)和Exception(异常),这两个子类也包含大量的子类。 ...
  • 主要介绍了Java异常处理与throws关键字用法,结合实例形式分析了java常见的异常、错误处理及throws关键字相关使用技巧、注意事项,需要的朋友可以参考下
  • 主要介绍了java处理异常2种机制关键字区别解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java异常以及关键字

    2020-07-19 23:12:06
    二、异常的五大关键字 1.try:存放可能发生异常的代码块 2.catch:捕获并处理异常 3.finally:无论如何都要执行的代码,除非jvm退出 4.throws:声明异常,将方法可能发生的异常列举出来 5.throw:抛出异常,自定义...
  • Java异常处理是通过5个关键词来实现的:try、catch、throw、throws和finally。一般情况下是用try来执行一段程序,如果系统会抛出(throw)一个异常对象,可以通过它的类型来捕获(catch)它,或通过总是执行代码块...
  • Java中应用程序在非正常的情况下停止运行主要包含两种方式: Error 和 Exception ,像我们熟知的 OutOfMemoryError 和 IndexOutOfBoundsException 等。在日常的开发过程中 Error 我们是不用处理的,一旦 Error 发生...
  • Java异常处理相关的5个关键字是: 、 、 、throw和throws 。答:try catch finally中国大学MOOC: 下列关于教学评价设计的说法,正确的有( )。答:教学评价的目标是为了促进学生的学习 正式与非正式评价相结合 根据...
  • Throwable有两个重要的子类:Exception(异常)和 Error(错误),二者都是 Java 异常处理的重要子类,各自都包含大量子类。Error(错误)是程序无法处理的错误,表示运行应用程序中较严重问题。大多数错误与代码编写者...
  • ThrowableThrowable是所有的错误和异常的超类,有两大实例 Error 一般不处理,由JVM抛出 ...—–运行时异常 :RuntimeException和其子类,直接中断功能,停止继续运行 这是Java异常体系: 异常声明J
  • trows捕获并向外抛出异常 trow抛出异常 try catch是内部捕获异常并做自定义处理 finally是无论是否有异常都会被处理的语句,除非在finally前存在被执行的system.exit(int i)时除外。
  • java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供良好的接口。...java异常处理是通过5个关键字来实现:try,catch,throw,throws,finally。一般情况下是用try来执行一段程序...
  • java异常处理的五个关键字

    千次阅读 2017-10-24 22:51:24
    传送门
  • 主要介绍了详解Java异常处理中throw与throws关键字的用法区别,这也是Java面试题目中的常客,需要的朋友可以参考下
  • 主要介绍了java处理异常的机制关键字throw和throws使用解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 问:异常处理关键字的作用和处理流程Java的异常处理主要通过try、catch、finally关键字来实现。try关键字对紧随其后一队花括号括起来的代码块(try代码块)进行异常扑捉,如果出现异常就跳转到catch模块。catch关键字...
  • ·throws关键字主要用于方法声明上,指的是当前方法之中异常后交给被调用处处理;范例1:class MyMath { public static int div(int x, int y) throws Exception { return x / y; } } public class Test { ...
  • java中用来抛出异常关键字是 catch

    千次阅读 2021-03-14 03:20:42
    java中用来抛出异常关键字是 catch答:×马克思主义的来源包括()答:马克思主义的政治经济学 科学社会主义 马克思主义哲学“风口理论”又叫“飞猪理论”,最早是雷军提出来的。答:对量身定制服装企业在我国很少。...
  • Java异常throw关键字

    2021-06-04 00:02:35
    可以使用throw关键字在指定的方法中抛出指定的异常 使用格式: throw new xxxException("异常产生的原因"); 注意: 1.throw关键字必须写在方法的内部 2.throw关键字后边new的对象必须是Exception或者Exception的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 183,643
精华内容 73,457
关键字:

java异常处理关键字

java 订阅