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