精华内容
下载资源
问答
  • 请说明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{
        ...
    }
    
    展开全文
  • 异常处理关键字 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文件:

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

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

    展开全文
  • Java异常处理的五个关键字

    万次阅读 2018-02-09 14:15:35
    (..•˘_˘•..) 版权声明:转载原创文章请以超链接形式请...异常处理关键字:try、catch、finally、throw、throws注意事项:1、错误不是异常,而是脱离程序员控制的问题。2、所有的异常类是从 java.lang.Exceptio...

    (..•˘_˘•..) 版权声明:转载原创文章请以超链接形式请注明原文章出处,尊重作者,实在不易! (..•˘_˘•..)

    异常:异常有的是因为用户错误引起,有的是程序错误引起的,还有其它一些是因为物理错误引起的。
    异常处理关键字:try、catch、finally、throw、throws
    注意事项:
    1、错误不是异常,而是脱离程序员控制的问题。
    2、所有的异常类是从 java.lang.Exception 类继承的子类。
    3、异常类有两个主要的子类:IOException 类和 RuntimeException 类。
    4、Java有很多的内置异常类。
    异常大致分类:
    1、用户输入了非法数据。
    2、要打开的文件不存在。
    3、网络通信时连接中断,或者JVM内存溢出。

    语法:

    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异常处理常用关键字

    千次阅读 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异常以及关键字

    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)它,或通过总是执行代码块...
  • trows捕获并向外抛出异常 trow抛出异常 try catch是内部捕获异常并做自定义处理 finally是无论是否有异常都会被处理的语句,除非在finally前存在被执行的system.exit(int i)时除外。
  • 主要介绍了java处理异常的机制关键字throw和throws使用解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java异常处理的五个关键字

    千次阅读 2017-10-24 22:51:24
    传送门
  • 主要介绍了java处理异常2种机制关键字区别解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java异常throw关键字

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

    2020-09-02 07:16:19
    与其他语言的模型相比,finally 关键字是对 Java 异常处理模型的最佳补充。接下来通过本文给大家介绍Java中Finally关键字及finally关键字的使用相关知识,感兴趣的朋友一起学习吧
  • 那么,java程序中的异常我们可以捕获然后处理,这样后面的程序就可以继续执行了; 上代码: package m12d28; public class ExceptionDemo01 { public static void main(String[] args) ...
  • 什么是异常   异常是程序中的一些错误,但...异常处理格式 try{ //有可能出现异常的语句 }catch(异常类 异常对象){ //编写异常处理的语句 }【catch(异常类 异常对象){ //编写异常处理的语句 }catch(...
  • 主要介绍了详解Java异常处理中throw与throws关键字的用法区别,这也是Java面试题目中的常客,需要的朋友可以参考下
  • ·throws关键字主要用于方法声明上,指的是当前方法之中异常后交给被调用处处理;范例1:class MyMath { public static int div(int x, int y) throws Exception { return x / y; } } public class Test { ...
  • 1.在定义一个方法的时候可以使用throws关键字声明,使用throws声明的方法表示此方法不处理异常,抛给方法的调用者处理。 2.格式:  public void tell()throws Exception{} 例子: public static void ...
  • java.lang.Throwable: ...相当于程序得了一个小毛病,把异常处理掉,程序可以执行。 Error:错误 错误就相当于程序得了一个无法治愈的毛病,必须修改源代码,程序才能执行。 异常产生的过程: 如果...
  • Java中的关键字有哪些?Java关键字(keyword)有多少个?Java的保留字(reserveword)有多少个?分别是什么?Java关键字分别是什么,作用是什么?
  • java中的关键字以及用法

    千次阅读 2018-08-12 22:01:32
    java关键字 Java关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字,还有特别意义的变量。Java关键字Java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能...
  • Java语言的关键字

    千次阅读 2019-05-18 15:43:56
    关键字 含义 abstract 表明类或者成员方法具有抽象属性 assert 断言,用来进行程序调试 boolean 基本数据类型之一,布尔类型 break ... 用在异常处理中,用来捕捉异常 char ...
  • Java50个关键字总结

    万次阅读 多人点赞 2018-09-15 15:40:44
    作业一:Java基础知识复习 一、关键字总结 1.abstract 修饰类: abstract修饰类,这个类就是抽象类,抽象类中可以有非抽象变量和成员变量,也可以有普通方法、构造方法。但是不能...
  • Java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的接口。 在Java中,每个异常都是一个对象,它是Throwable类或其子类的实例。当一个方法出现异常后便抛出一个异常对象,该对象中包含有...
  • Java标识符和关键字

    千次阅读 多人点赞 2019-04-17 14:49:39
    Java标识符定义 ...3、 标识符不能以数字开头,不能是java中的关键字。例如: 正确的标识符 Username、username123、user_name、_userName、$username 不正确的标识符: 123username、class、87.2、He...
  • 异常处理的第一种方式,交给别人处理 作用: 当方法内部抛出异常对象的时候,那么我们就必须处理这个异常对象 可以使用throws关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理(自己不处理,给别人...
  • Java的finally关键字

    2017-10-11 10:57:04
    一般用于释放资源,比如IO流。 finally用来做什么对于没有垃圾回收和析构函数自动调用机制的...在异常没有被当前的异常处理程序捕获的情况下,异常处理机制也会跳到更高一层的异常处理程序之前,执行finally子句: pub

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 172,123
精华内容 68,849
关键字:

java异常处理的关键字

java 订阅