Java关键字throw、throws、Throwable怎么用

本文小编为大家详细介绍“Java关键字throw、throws、Throwable怎么用”，内容详细，步骤清晰，细节处理妥当，希望这篇“Java关键字throw、throws、Throwable怎么用”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。

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());
    }
}

读到这里，这篇“Java关键字throw、throws、Throwable怎么用”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注亿速云行业资讯频道。