精华内容
下载资源
问答
  • Java中异常以及关键字

    2020-07-19 23:12:06
    异常指程序运行发生的意外,会中断程序。 二、异常的五大关键字 1.try:存放可能发生异常的代码块 2.catch:捕获并处理异常 3.finally:无论如何都要执行的代码,除非jvm退出 4.throws:声明异常,将方法可能发生...

    一、什么是异常:
    异常指程序运行中发生的意外,会中断程序。
    二、异常的五大关键字
    1.try:存放可能发生异常的代码块(当try中发生异常时会立即执行catch中的代码)
    2.catch:捕获并处理异常
    3.finally:无论如何都要执行的代码,除非Java虚拟机退出
    4.throws:声明异常,将方法可能发生的异常列举出来
    5.throw:抛出异常,自定义异常
    三、常见的异常类型
    1.Exception :所有异常的父类
    2.ArithmeticException:算数异常 不符合数学的相关规定
    3.ArrayIndexOutOfBoundsException;数组下标越界
    4.NullPointerException:空指针异常 Pet pet =null pet.age=9;
    5.ClassNotFoundException:加载的类找不到
    6.IllegalArgumentException:方法接收到非法参数
    7.ClassCastException:类的异常转换 dog–>Cat
    8.NumberFormatException:数据转化异常 “fs”–>int
    四、异常处理机制三个模块的搭配问题
    1.try必须有
    2.try不能独立存在
    五、异常的执行顺序 try–catch–finally
    1.有异常:try–>catch–>finally
    2.无异常:try–>finally
    3.try块一旦发生异常会立即跳入catch进行处理
    六、多重catch
    1.使用场景:一段代码可能发生多种不同类型的异常时
    2.摆放顺序:先子后父,将最可能发生的异常往前放
    七、异常的分类
    1.throwable:错误和异常的父类
    2.Error:错误 程序自身无法解决的严重问题
    3.Exception:异常
    八、throw和throws的区别
    4.检查异常:SQLException+ClassNotFoundException
    1.throw:
    抛出一个异常,可以是系统定义的,也可以是自己定义的。下面举两个例子:
    2.throws:(针对一个方法抛出的异常)
    抛出一个异常,可以是系统定义的,也可以是自己定义的。
    如果是系统异常的话可以什么都不用做,也可以针对方法抛出一个异常,因为系统异常是可以被系统自动捕获的,所以这个异常究竟是要在方法内部解决还是交给上层函数去解决其实效果是一样的。但是我查了很多资料,即使会抛出异常能被系统所捕获的话还是建议针对方法写一个throws,因为这样在完成一个大型任务的时候可以让别的程序员知道这里会出现什么异常。
    如果是自己定义的异常,则必须要用throws抛出该方法可能抛出的异常,否则编译会报错。

    展开全文
  • 异常处理关键字 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{
        ...
    }
    
    展开全文
  • java异常处理常用关键字

    千次阅读 2019-08-06 20:04:39
    异常处理两种方式: 1、捕获异常...异常处理的5 个关键字: try, catch, finally throw, throws 捕获异常时,:先捕获小异常再捕获大异常 异常处理格式 try{ //可能出异常的代码 }catch(异常类 对象){ //处...
    异常处理两种方式: 1、捕获异常:try catch 直接处理可能出现的异常! 
    2、声明异常:throws 声明告诉调用者可能的异常,暴露问题,调用者自己处理!
    
    异常处理的5 个关键字: try,	catch,	 finally	 throw,	throws
    捕获异常时,:先捕获小异常再捕获大异常
    
    异常处理格式 
    try{
     	//可能出异常的代码
     }catch(异常类 对象){
     //处理该异常类型的语句 } [finally] {
     //一定会执行的代码 //catch 块使用 System.exit(1);除外 
    }
    备注:当 try 语句块出现异常,程序会自动跳到 catch 语句块去找匹配的异常类型,并执行 异常处理语句,finally 语句块是异常的统一出口。
    
    throws  & throw
    throws 用于在方法上声明该方法不需要处理的异常类型。 
    throw 用于抛出具体异常类的对象。 
    throws 与 throw的区别: 
    thorws 用在方法上,后面跟异常类名,可以是多个异常类。
     	throw 用在方法内,后面跟异常对象,只能是一个。
    
    Finally 异常的统一出口: 
    不管 try块程序是否异常,也不管哪个 catch 执行,finally 块总会执行。
     try语句块或会执行的 catch 语句块使用了 JVM 系统退出语句例外;//System.exit(1); 
    try 块必须和 catch 块或和 finally 同在,不能单独存在,二者必须出现一个。 
    不要在finally 中使用return 或 throw 语句,否则将会导致 try、catch 中的 return 或 throw 失 效。
    
    public class Demo19 {
     public static void main(String[] args) {
     try{ 
    System.out.println(17/0); 
    }catch(Exception e){
     //e.printStackTrace(); System.out.println("程序错误,请修正!"); 
    }finally{ 
    System.out.println("这是finally代码块!");
     } 
    } 
    }
    输出: 
    程序错误,请修正! 
    这是finally代码块!
    
    
    展开全文
  • 主要介绍了Java异常处理与throws关键字用法,结合实例形式分析了java常见的异常、错误处理及throws关键字相关使用技巧、注意事项,需要的朋友可以参考下
  • Java处理异常机制以及五个关键字

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

    万次阅读 2018-02-09 14:15:35
    (..•˘_˘•..) 版权声明:转载原创文章请以超链接形式请...异常处理关键字:try、catch、finally、throw、throws注意事项:1、错误不是异常,而是脱离程序员控制的问题。2、所有的异常类是从 java.lang.Exceptio...
  • 主要介绍了java处理异常2种机制关键字区别解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java中50个关键字以及各自用法大全

    千次阅读 多人点赞 2019-11-10 17:50:38
    关键字和保留字的区别 正确识别java语言的...保留字是为java预留的关键字,他们虽然现在没有作为关键字,但在以后的升级版本有可能作为关键字。 识别java语言的关键字,不要和其他语言如c/c++的关键字混淆...
  • 主要介绍了详解Java异常处理中throw与throws关键字的用法区别,这也是Java面试题目的常客,需要的朋友可以参考下
  • Java中关键字有哪些?Java关键字(keyword)有多少个?Java的保留字(reserveword)有多少个?分别是什么?Java关键字分别是什么,作用是什么?
  • throws是获取异常 throw是抛出异常 ...try是将会发生异常的语句括起来,从而进行异常处理,也可以在try块抛出新的异常 catch是如果有异常就会执行他里面的语句 finally不论是否有异常都会进行执行的语句
  • Java异常处理是通过5个关键词来实现的:try、catch、throw、throws和finally。一般情况下是用try来执行一段程序,如果系统会抛出(throw)一个异常对象,可以通过它的类型来捕获(catch)它,或通过总是执行代码块...
  • 工程师培训资料 标题Java培训系列课程-throws关键字精品培训 培训人xx 本章学习目标 了解异常的产生原理 掌握异常处理语句的基本格式 掌握throwthrows关键字的作用 可以自定义异常 了解Exception与RuntimeException...
  • 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) ...
  • java异常处理的五个关键字

    千次阅读 2017-10-24 22:51:24
    传送门
  • ·throws关键字主要用于方法声明上,指的是当前方法之中异常后交给被调用处处理;范例1:class MyMath { public static int div(int x, int y) throws Exception { return x / y; } } public class Test { ...
  • Java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的接口。 在Java中,每个异常都是一个对象,它是Throwable类或其子类的实例。当一个方法出现异常后便抛出一个异常对象,该对象包含有...
  • java中关键字以及用法

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

    万次阅读 多人点赞 2018-04-14 18:07:27
    大致含义关键字含义abstract表明类或者成员方法具有抽象属性assert断言,用来进行程序调试boolean基本数据类型之一,布尔类型break提前跳出一个块byte基本数据类型之一,字节类型case用在switch语句之,表示其中的...
  • 关于Java中标识符和关键字的整理

    千次阅读 2018-07-19 11:30:19
    标识符不能是Java中关键字和保留字,但是可以包含关键字和保留字。 标识符不能包含空格。 标识符只能包含美元符号($),不能包含@、#等其他的特殊字符/ 什么是Java关键字java语言一些具有特殊用途的...
  • java.lang.Throwable: ...相当于程序得了一个小毛病,把异常处理掉,程序可以执行。 Error:错误 错误就相当于程序得了一个无法治愈的毛病,必须修改源代码,程序才能执行。 异常产生的过程: 如果...
  • java中50个关键字

    千次阅读 2019-10-31 21:08:27
    关键字和保留字的区别 ...保留字是为java预留的关键字,他们虽然现在没有作为关键字,但在以后的升级版本有可能作为关键字。 识别java语言的关键字,不要和其他语言如c/c++的关键字混淆。...
  • 1.在定义一个方法的时候可以使用throws关键字声明,使用throws声明的方法表示此方法不处理异常,抛给方法的调用者处理。 2.格式:  public void tell()throws Exception{} 例子: public static void ...
  • Java中的throws关键字

    千次阅读 2018-03-31 23:06:37
    1. throws关键字 throws关键字主要用于方法声明上,指的是当方法之出现异常后交由被调用处处理。范例:使用throwsclass MyMath{ //由于存在throws,那么就表示此方法里面产生的异常交给被调用处处理 public ...
  • java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供良好的接口。...java异常处理是通过5个关键字来实现:try,catch,throw,throws,finally。一般情况下是用try来执行一段程序...
  • 详解java中关键字

    2019-08-28 21:30:28
    关键字中所有字母都为小写 2:关键词功能分类: 2.1:用于定义【访问权限修饰符】的关键字 private protected public 2.2:用于定义【类】【函数】【变量修饰符】的关键词 abstract final static synchronized ...

空空如也

空空如也

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

java中异常处理关键字

java 订阅