详细介绍Java关键字throw throws Throwable的用法与区别

目录
  • 1. Throwable
    • 1.1 扩展-Error
    • 1.2 扩展-Exception
  • 2. throws
    • 2.1 扩展
  • 3. throw
    • 3.1 扩展
  • 4. 总结

throw,意为“投掷、抛、扔”。Throw、Throws和Throwable三者都用于异常处理。

1. Throwable

Throwable在Java中是异常处理这个分支的顶级父类,其它所有异常处理的实现都依赖于Throwable

打开Java官方文档(Java8版本),找到Throwable,它的直接子类为Error和Exception。

Error和Exception两者的特点在于Error异常程序无法处理,只能交由人工介入修改代码,比如栈溢出、堆溢出等等;而Exception异常可以提前发觉,并作出有效处理。

1.1 扩展-Error

在Error中,常见的有栈溢出和堆溢出等等。

举个例子,StackOverflowError

public class ErrorTest {
    public static void main(String[] args) {
        main(args);
    }
}

无限递归,执行这个程序就会报栈溢出异常。

再比如堆异常,OutOfMemoryError

public class ErrorTest {
    public static void main(String[] args) {
        Integer[] testArray = new Integer[1024*1024*1024];
    }
}

1.2 扩展-Exception

在Exception中就有非常多我们所熟知的异常情况了,比如NullPointerException(空指针异常)、ArrayIndexOutOfBoundsException(数组下标越界)、NumberFormatException(数字格式化异常)等等。

public class ExceptionTest {
    public static void main(String[] args) {
        int[] testArray = null;
        System.out.println(testArray[0]);  //空指针异常
    }
}
public class ExceptionTest {
    public static void main(String[] args) {
        int[] testArray = new int[3];
        System.out.println(testArray[3]);   //数组下标越界
    }
}
public class ExceptionTest {
    public static void main(String[] args) {
        String num = "abc";
        System.out.println(Integer.parseInt(num));    //数字格式化异常
    }
}

2. throws

throws应用在方法声明处,指明此方法在执行时可能会出现的异常类型。一旦该方法执行时出现异常,就会在异常代码处生成一个异常类的对象,此对象满足Throws后的异常类型时,就会被抛出。这里有两个过程,代码有异常时

1. 生成一个异常对象;

2. throws捕获到这个异常,将异常对象抛出

throws和try-catch-finally一起称为异常处理的两种方式。

try-catch-finally是在出现异常时主动处理掉异常,使得程序可以继续执行下去;而throws捕获到异常之后向上抛出异常对象,不去真正地处理这个异常。

所谓向上抛出异常对象,是将异常对象交给调用者去处理,比如方法A调用方法B,B通过throws抛出异常,而A可以选择使用try-catch-finally处理掉异常,也可以通过throws继续向上抛出异常对象,直到异常被真正处理掉。如果一直没有方法去处理异常,异常对象最终会被抛给JVM,从而导致程序停止运行。

@Test
public void throwsTest(){   //调用者解决抛出的异常
    try{
        formatChange("abc");
    }
    catch (NumberFormatException e){
        System.out.println("转换格式错误!");
    }
    catch (Exception e){
        System.out.println("出现错误");
    }
}
private int formatChange(String str) throws NumberFormatException{    //出现异常向上抛出
    return Integer.parseInt(str);
}

2.1 扩展

——如何选择try-catch-finally还是throws?

当一个方法中存在异常需要处理,在大多数情况下,既可以选择try-catch-finally直接处理掉这个异常,也可以选择throws向上抛出异常,交给调用者去处理(异常抛到最后,总要有一方真正地去处理这个异常,怎么处理?还是用try-catch-finally呗),在选择上比较自由,但是,出现以下两种情况时,需要遵循一定的规则(如有补充,敬请指出)。

  • 如果父类中被重写的方法没有使用throws抛出异常,则子类重写的方法也不能使用throws抛出异常,也就意味着这种情况必须使用try-catch-finally去处理。
  • 在方法A中,先后调用了另外的几种方法,这几种方法是递进关系执行的且其中很多方法都存在异常需要处理,这种情况建议被调用的几个方法使用throws向上抛出异常,在方法A中,使用try-catch-finally统一处理掉这些异常。

针对第一条,这是一个规定,子类中重写的方法使用throws抛出的异常必须不大于父类中被重写的方法抛出异常的范围。举个例子,父类中的方法B抛出NullPointerException异常,则子类中重写B方法就不能抛出如Exception这种比NullPointerException范围更大的异常;如果父类中被重写的方法没有抛出任何异常,则子类更不能抛出异常。

为什么?展示一段代码。

//假设父类中的方法B抛出NullPointerException异常,子类中的方法B可以抛出Exception
private void test(ParentClassTest parent){
    try{
        parent.B();
    }
    catch(NullPointerException e){
        System.out.println("出现了空指针异常");
    }
}

在本示例中,假设父类中的方法B抛出NullPointerException异常,子类中重写的方法B可以抛出Exception。那么传进给test方法的参数如果是父类的实例化对象,那么调用test方法没有任何问题。如果传进的参数是子类的实例化对象,再去调用子类重写的方法B,那么就有可能抛出Exception异常,try-catch结构就压不住这个异常了,这显然是一个不合理的操作。

针对第二条,假设方法A中调用了方法C、D、E,这三个方法都有可能产生异常,且存在递进关系,也就是D、E执行需要C执行完成、E执行依赖C、D执行完成。那么就推荐在C、D、E中向上抛出异常,在方法A中集中处理。为什么?如果C、D、E都是向上抛出异常,而A使用try-catch-finally去处理这个异常,如果某个方法真的出现异常,则不再继续执行。而如果C、D、E都使用try-catch-finally直接解决掉异常,那么即使产生了异常,方法A也不会接收到异常的产生,那么还会接着往下执行,但是C出现了异常,再执行D、E没有任何意义。

3. throw

如果在程序编写时有手动抛出异常的需求,则可以使用throw

throw使用在方法体内。与try-catch-finally和throws都不同,异常处理的两个阶段:1.遇到异常,生成异常对象;2.捕获到异常,进行抛出或处理。try-catch-finally和throws都处在第二个阶段,都是捕获到异常后的相关处理,一般使用系统根据异常类型自动生成的异常对象进行处理。而throw应用在第一阶段,手动地产生一个异常对象。

举一个例子,判断一个数值是否为非负数,如果为负数,则抛出异常。

class ThrowTest{
    private int Number;
    public void judge(int num){
        if(num>=0){
            this.Number = num;
        }
        else{
            throw new RuntimeException("传入参数为负数");
        }
    }
}
@Test
public void test2(){
    ThrowTest throwTest = new ThrowTest();
    throwTest.judge(-100);
}

成功抛出异常。

使用try-catch捕获一下异常。

@Test
public void test2(){
    ThrowTest throwTest = new ThrowTest();
    try{
        throwTest.judge(-100);
    }
    catch (RuntimeException e){
        System.out.println(e.getMessage());
    }
}

如果把throw抛出的异常改为Exception,则直接报错,也就是不能编译。Exception包含两种异常:编译时异常和运行时异常,前者在编译前就要检查是否有可能产生编译时异常;后者是在编译后运行时才会判断的异常。而throw new Exception包含了编译时异常,需要显式处理掉这个异常,怎么处理?try-catch-finally或者throws

class ThrowTest{
    private int Number;
    public void judge(int num) throws Exception{
        if(num>=0){
            this.Number = num;
        }
        else{
            throw new Exception("传入参数为负数");
        }
    }
}

调用方也要随着进行更改。

@Test
public void test2(){
    ThrowTest throwTest = new ThrowTest();
    try{
        throwTest.judge(-100);
    }
    catch (RuntimeException e){
        System.out.println(e.getMessage());
    }
    catch (Exception e){
        System.out.println(e.getMessage());
    }
}

3.1 扩展

——自定义异常类

throw还可以抛出自定义异常类。

自定义异常类的声明需要继承于现有的异常体系。

class MyException extends RuntimeException{
    static final long serialVersionUID = -703489719076939L;   //可以认为是一种标识
    public MyException(){}
    public MyException(String message){
        super(message);
    }
}

此时我们可以抛出自定义的异常

class ThrowTest{
    private int Number;
    public void judge(int num) throws MyException{
        if(num>=0){
            this.Number = num;
        }
        else{
            throw new MyException("不能输入负数");
        }
    }
}

调用者修改

@Test
public void test2(){
    ThrowTest throwTest = new ThrowTest();
    try{
        throwTest.judge(-100);
    }
    catch (MyException e){
        System.out.println(e.getMessage());
    }
}

4. 总结

三者共同点在于都属于是异常处理的范畴内。

不同点:

  • Throwable是异常处理这个分支的顶层父类,其它异常类的实现都需要继承于Throwable
  • throw应用在方法体内,是生成异常对象的一种方式
  • throws应用在方法声明处,声明出可能要抛出的各种异常类,是处理异常的方式

到此这篇关于详细介绍Java关键字throw throws Throwable的用法与区别的文章就介绍到这了,更多相关Java关键字throw throws Throwable内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • java自定义异常以及throw和throws关键字用法

    java中内置了很多可能在编程时出现的大部分异常.除此之外,用户可以使用一个类继承Exception类即可继承自定义类异常. 在程序中自定义类,大体上分为以下几个步骤: 1.创建自定义异常类 2.在方法中通过throw关键字抛出异常对象. 3.如果在当前抛出异常的方法中处理异常,可以使用try-catch语句块捕捉并处理异常,否则在方法的声明处通过throws指明要抛出给方法调用者的异常,继续进行下一步操作. 4.再出现异常的方法的调用者中捕获处理异常. 下面是我创建自定义异常.在项目中创建类M

  • 如何区分JAVA中的throws和throw

    throws和throw: throws:用来声明一个方法可能产生的所有异常,不做任何处理而是将异常往上传,谁调用我我就抛给谁. 用在方法声明后面,跟的是异常类名 可以跟多个异常类名,用逗号隔开 表示抛出异常,由该方法的调用者来处理 throws表示出现异常的一种可能性,并不一定会发生这些异常 throw:则是用来抛出一个具体的异常类型. 用在方法体内,跟的是异常对象名 只能抛出一个异常对象名 表示抛出异常,由方法体内的语句处理 throw则是抛出了异常,执行throw则一定抛出了某种异常 分别

  • 简述Java中throw-throws异常抛出

    目录 一.throws抛出异常 Throws抛出异常的规则: 二.使用throw抛出异常 三.比较 3.1 在声明方法时候抛出异常 3.2 在方法中抛出异常 任何Java代码都可以抛出异常,如:自己编写的代码.来自Java开发环境包中代码,或者Java运行时系统.无论是谁,都可以通过Java的throw语句抛出异常.从方法中抛出的任何异常都必须使用throws子句. 一.throws抛出异常 如果一个方法可能会出现异常,但没有能力处理这种异常,可以在方法声明处用throws子句来声明抛出异常.例

  • Java throw和throws使用区别分析

    代码实例: 问题:为什么testRunntimeException()方法没有出现编译错误提示,而testCheckedException()方法却出现unhandle exception? 分析: Excepiton分两类:checked exception.runtime exception:直接继承自Exception就是checked exception,继承自RuntimeException就是runtime的exception. 你可以简单地理解checked exception就是

  • 简单了解Java关键字throw和throws的区别

    这篇文章主要介绍了简单了解Java关键字throw和throws的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 抛出异常有三种形式 throw throws 系统自动抛异常 一.系统自动抛异常 当程序语句出现一些逻辑错误.主义错误或类型转换错误时,系统会自动抛出异常:(举个栗子) public static void main(String[] args) { int a = 5, b =0; System.out.println(5/b

  • 简单讲解java中throws与throw的区别

    Java中throws和throw的区别讲解 当然,你需要明白异常在Java中式以一个对象来看待. 并且所有系统定义的编译和运行异常都可以由系统自动抛出,称为标准异常,但是一般情况下Java 强烈地要求应用程序进行完整的异常处理,给用户友好的提示,或者修正后使程序继续执行. 直接进入正题哈: 1.用户程序自定义的异常和应用程序特定的异常,必须借助于 throws 和 throw 语句来定义抛出异常. 1.1   throw是语句抛出一个异常. 语法:throw (异常对象);         

  • java中throws与try...catch的区别点

    throws是将异常抛出,后续代码不再执行.而try-catch是将异常抛出,并且要继续执行后面的代码. package com.oracle; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class Demo01Exception { /*Exception:编译期间异常,进行编译(写代码的过程) * runtimeException:运行期异

  • JAVA异常处理机制之throws/throw使用情况的区别

    JAVA中throw和throws的区别:https://www.cnblogs.com/xiohao/p/3547443.html 区别:(摘自上面的博客) 1.throws出现在方法函数头:而throw出现在函数体. 2.throws表示出现异常的一种可能性,并不一定会发生这些异常:throw则是抛出了异常,执行throw则一定抛出了某种异常. 3.两者都是消极处理异常的方式(这里的消极并不是说这种方式不好),只是抛出或者可能抛出异常,但是不会由函数去处理异常,真正的处理异常由函数的上层调用

  • 详细介绍Java关键字throw throws Throwable的用法与区别

    目录 1. Throwable 1.1 扩展-Error 1.2 扩展-Exception 2. throws 2.1 扩展 3. throw 3.1 扩展 4. 总结 throw,意为“投掷.抛.扔”.Throw.Throws和Throwable三者都用于异常处理. 1. Throwable Throwable在Java中是异常处理这个分支的顶级父类,其它所有异常处理的实现都依赖于Throwable 打开Java官方文档(Java8版本),找到Throwable,它的直接子类为Error和Ex

  • 详细介绍Java函数式接口

    目录 Java-函数式接口 1.自定义函数式接口 1.1概述 1.2格式 1.3@FunctionalInterface注解 1.4自定义函数式接口 2.函数式编程 2.1Lambda的延迟执行 2.2使用Lambda作为参数和返回值 3.常用函数式接口 3.1Supplier接口 3.2Consumer接口 3.3Predicate接口 3.4Function接口 Java-函数式接口 1.自定义函数式接口 1.1概述 函数式接口在Java中是指:**有且仅有一个抽象方法的接口.**当然接口中

  • 详细介绍Java阿里云的短信验证码实现

    阿里云手机短信验证码 第一步 登录阿里云开放平台 1.进入阿里云开放平台---->点击控制台 2.点击AccessKey管理 3.点击之后会弹出提示,选择开始使用子用户 4.新建一个用户组,然后按要求填写即可 5.创建一个用户,按要求填写内容,勾选编程访问 6.会得到AccessKey(id,密码) 要将这个账号保存下来! //用户登录名称 ==================== //AccessKey ID ==================== //AccessKey Secret ==

  • 详细介绍Java中的各种锁

    一.一张图了解21种锁 二.乐观锁 应用 CAS 思想 一种乐观思想,假定当前环境是读多写少,遇到并发写的概率比较低,读数据时认为别的线程不会正在进行修改 实现 写数据时,判断当前 与期望值是否相同,如果相同则进行更新(更新期间加锁,保证是原子性的) 三.悲观锁 应用 synchronized.vector.hashtable 思想: 一种悲观思想 ** ,即认为写多读少,遇到并发写的可能性高 实现 每次读写数据都会认为其他线程会修改,所以每次读写数据时都会上锁 缺点 他线程想要读写这个数据时,

  • C语言详细分析讲解关键字const与volatile的用法

    目录 一.const 只读变量 二.const 全局变量的分歧 三.const 的本质 四.const 修饰函数参数和返回值 五.volatile 解析 六.小结 一.const 只读变量 const 修饰的变量是只读的,本质还是变量 const 修饰的局部变量在栈上分配空间 const 修饰的全局变量在全局数据区分配空间 const 只在编译期有用,在运行期无用 const 修饰的变量不是真的常量,它只是告诉编译器该变量不能出现在赋值符号的左边. 二.const 全局变量的分歧 在现代C语言编

  • Java中CyclicBarrier和CountDownLatch的用法与区别

    目录 前言 CountDownLatch 例子 CyclicBarrier 构造函数 例子 两者区别 前言 CyclicBarrier和CountDownLatch这两个工具都是在java.util.concurrent包下,并且平时很多场景都会使用到. 本文将会对两者进行分析,记录他们的用法和区别. CountDownLatch CountDownLatch是一个非常实用的多线程控制工具类,称之为"倒计时器",它允许一个或多个线程一直等待,直到其他线程的操作执行完后再执行. Coun

  • java 关键字super详解及用法

    java 关键字super详解 一.super关键字 在JAVA类中使用super来引用父类的成分,用this来引用当前对象,如果一个类从另外一个类继承,我们new这个子类的实例对象的时候,这个子类对象里面会有一个父类对象.怎么去引用里面的父类对象呢?使用super来引用,this指的是当前对象的引用,super是当前对象里面的父对象的引用. 1.1.super关键字测试 package cn.galc.test; /** * 父类 * @author gacl * */ class Fathe

  • 详细介绍Java内存泄露原因

    一.Java内存回收机制 不论哪种语言的内存分配方式,都需要返回所分配内存的真实地址,也就是返回一个指针到内存块的首地址.Java中对象是采用new或者反射的方法创建的,这些对象的创建都是在堆(Heap)中分配的,所有对象的回收都是由Java虚拟机通过垃圾回收机制完成的.GC为了能够正确释放对象,会监控每个对象的运行状况,对他们的申请.引用.被引用.赋值等状况进行监控,Java会使用有向图的方法进行管理内存,实时监控对象是否可以达到,如果不可到达,则就将其回收,这样也可以消除引用循环的问题.在J

  • Java关键字instanceof的两种用法实例

    instanceof关键字用于判断一个引用类型变量所指向的对象是否是一个类(或接口.抽象类.父类)的实例.   举个例子: 复制代码 代码如下: public interface IObject { } public class Foo implements IObject{ } public class Test extends Foo{ } public class MultiStateTest {         public static void main(String args[])

随机推荐