Java中除try...catch外的异常处理：throws声明和抛出异常

[id_[id_[id_210[id_798490034]167443]62412086]21159184]

当定义一个方法时，能够用 throws 关键字来进行声明。使用了 throws 关键字，就意味着这个方法不会去处理异常，而是将异常留给它的调用者去处理。你是否会觉得它是不负责任的呢？

哈哈,看一下demo吧

[id_1009781985]
 private void readFile() throws IOException {
        InputStream is = new FileInputStream("jaywei.txt");
        int b;
        while ((b = is.read()) != -1) {

        }
    }

从方法中声明抛出的任何异常都必须使用throws子句。

抛出异常

throw 关键字的作用是抛出一个 Throwable 类型的异常，它通常出现在函数体里。在异常处理过程中，try 语句需要捕获的是一个异常对象，实际上这个异常对象是可以自己抛出的。

抛出一个属于 RuntimeException 类的异常对象。

throw new RuntimeException(e);

Java 的 throw 语句可以用于抛出任何 Java 代码中的异常。

注意点四，关于 try-catch-finally-return 的执行顺序。

try-catch-finally-return 执行描述

看一个例子

 public static void main(String[] args) throws IOException {
        System.out.println("result：" + test());
    }

    private static int test() {
        int temp = 1;
        try {
            System.out.println("start execute try,temp is:"+temp);
            return ++temp;
        } catch (Exception e) {
            System.out.println(开始执行。捕获的临时值是：+temp);
            return ++temp;
        } finally {
            System.out.println(开始执行，最终，临时变量是： + temp);
            ++temp;
        }
    }

运行结果：

start execute try,temp is:1
start execute finally,temp is:2
result:2

分析

五、Java异常类的几个重要方法

先来喵一眼异常类的所有方法，如下图:

getMessage

Returns the detail message string of this throwable.

getMessage 会将 Throwable 的 detailMessage 属性返回出来。detailMessage 这个属性表示的是发生异常时的详细消息描述。

当 FileNotFoundException 异常发生时，此 detailMessage 包含找不到的文件的名字。

getLocalizedMessage

Creates a localized description of this throwable.Subclasses may override this
method in order to produce alocale-specific message. For subclasses that do not
override thismethod, the defaultImplementation causes the emergence of the same result.  // 实施引起相同结果的出现。
as getMessage()

本地化描述关于可抛类。子类能够对该方法进行重写，从而生成针对语言环境的消息。对于那些没有覆盖此方法的子类，其默认实现会给出与调用 getMessage()相同的结果。

getCause

Returns the cause of this throwable or null if thecause is nonexistent or unknown.

返回可抛出此事件的原因，若原因不存在或未知，则返回 null。

printStackTrace

Prints this throwable and它追溯到标准错误流。.

The() method for
this object.Remaining线条代表之前记录的数据。by the
method fillInStackTrace(). 

该方法将堆栈跟踪信息打印到标准错误流。

剩余的行表示先前被方法 fillInStackTrace()记录的数据。

 java.lang.NullPointerException
         at MyClass.mash(MyClass.java:9)
         at MyClass.crunch(MyClass.java:6)
         at MyClass.main(MyClass.java:3)

六、自定义异常

自定义异常一般是去定义一个继承自 Exception 类的子类。

那么，为什么需要自定义异常？

下面是我司自定义异常类的一个简单demo

public class BizException extends Exception {
    //错误信息
    private String message;
    //错误码
    private String errorCode;

    public BizException() {
    }

    public BizException(String message, String errorCode) {
        this.message = message;
        this.errorCode = errorCode;
    }

    @Override
    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }
}

跑个main方测试一下

public class TestBizException {

    public static void testBizException() throws BizException {
        System.out.println(从 testBizException()中抛出 BizException。);
        throw new BizException("100","哥，我错了");
    }

    public static void main(String[] args) {
        try {
            testBizException();
        } catch (BizException e) {
            System.out.println("自己定义的异常");
            e.printStackTrace();
        }
    }
}

运行结果：

exception.BizException: 100
throwing BizException from testBizException()
自己定义的异常
    at exception.TestBizException.testBizException(TestBizException.java:7)
    at exception.TestBizException.main(TestBizException.java:12)

Java7 有新的 try-with-resources 语句。这种语句具有特定的功能和特点。它在处理资源管理方面提供了更便捷的方式。与传统的 try-catch 语句相比，它能够自动管理资源的关闭。例如，在文件操作、数据库连接等场景中，使用 try-with-resources 语句可以更方便地确保资源的正确释放。

Java7 提供了一个新功能叫 try-with-resources ，它是用来进行自动资源管理的。

在 try-with-resources出现之前

try{
    打开诸如文件、数据库连接、套接字等资源。
} catch (FileNotFoundException e) {
    
}finally{
    // close resources
}

Java7 出现了 try-with-resources 之后，就可以利用资源来实现相关功能。

try(// open resources here){
    // use resources
} catch (FileNotFoundException e) {
    // exception handling
}
资源在 try-catch 块执行完毕后就会被关闭。

Java7使用资源demo

public class Java7TryResourceTest {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader(
                "C:/jaywei.txt"))) {
            System.out.println(br.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用了 try-with-resources的好处

八、异常链

我们常常想要在捕获一个异常之后抛出另一个异常，同时希望能把原始异常的信息保存下来，这种情况被称作异常链。

抛出了一个新的异常信息，这会致使原有的异常信息丢失。在 JDk1.4 之前，程序员必须自行编写代码来留存原始异常信息。如今，所有 Throwable 子类在其构造器中都能够接收一个 cause（异常因由）对象作为参数。

这个 cause 是用于表示原始异常的。通过将原始异常传递给新的异常，就能够做到即使在当前位置创建并抛出了新的异常，也可以凭借这个异常链去追踪到异常最初发生的位置。

使用方式如下：

public class TestChainException {

    public void readFile() throws MyException{
        try {
            InputStream is = new FileInputStream("jay.txt");
            Scanner in = new Scanner(is);
            while (in.hasNext()) {
                System.out.println(in.next());
            }
        } catch (FileNotFoundException e) {
            //e 保存异常信息
            throw new MyException("文件在哪里呢", e);
        }
    }

    public void invokeReadFile() throws MyException{
        try {
            readFile();
        } catch (MyException e) {
            //e 保存异常信息
            throw new MyException("文件找不到", e);
        }
    }

    public static void main(String[] args) {
        TestChainException t = new TestChainException();
        try {
            t.invokeReadFile();
        } catch (MyException e) {
            e.printStackTrace();
        }
    }

}

//MyException 构造器
public MyException(String message, Throwable cause) {
        super(message, cause);
    }

运行结果：

我们能够看到有保存下来的异常信息。如果将 cause（也就是 FileNotFoundException 的 e）去除，那么来看一下运行结果。

可以发现，原始异常信息在少了 Throwablecause 之后就不翼而飞了。

九、异常匹配

当抛出异常时，异常处理系统会依据代码的书写顺序去找出“最近”的处理程序。找到与之匹配的处理程序后，它便认定异常将会得到处理，接着就不会再继续进行查找了。

查找时不要求抛出的异常与处理程序的异常完全一致。派生类的对象能够拥有其基类的处理程序。

看demo

package exceptions;
//: exceptions/Human.java
捕捉异常层次结构。

class Annoyance extends Exception {}
class Sneeze extends Annoyance {}

public class Human {
  public static void main(String[] args) {
    // Catch the exact type:
    try {
      throw new Sneeze();
    } catch(Sneeze s) {
      System.out.println("Caught Sneeze");
    } catch(Annoyance a) {
      System.out.println("Caught Annoyance");
    }
    // Catch the base type:
    try {
      throw new Sneeze();
    } catch(Annoyance a) {
      System.out.println("Caught Annoyance");
    }
  }
}

运行结果：

catch(Annoyance a)能够捕获 Annoyance 以及由它派生出来的所有异常。如果捕获了基类的异常，那么就能够匹配所有派生类的异常。

try {
      throw new Sneeze();
    } catch(Annoyance a) {
    } catch(Sneeze s) { //这句编译器会报错,因为异常已由前面catch子句处理
    }

Java 存在一种常见的异常叫做 NullPointerException 。

空指针异常是一个较为常见的异常类。简单来说，当调用了未进行初始化的对象或者是不存在的对象时，就会引发该异常。

ArithmeticException

算术异常类。在程序中，当出现除数为 0 这样的运算时，就会产生这样的异常。

ClassCastException

类型强制转换会引发异常，这种异常是 JVM 在检测到两个类型间转换不兼容时所引发的运行时异常。

发生了数组索引越界异常。 数组索引超出了其合法范围，导致了该异常的出现。 这种异常通常在访问数组元素时，使用了无效的索引值而引发。 例如，试图访问数组范围之外的元素，就会产生数组索引越界异常。 它是 Java 编程中常见的异常之一，需要开发者注意数组索引的合法性，以避免此类异常的发生。

数组下标越界异常，跟数组打交道时，需要注意一下这个异常。

FileNotFoundException

文件未找到会出现异常。通常是因为要读或者写的文件找不到，从而引发了该异常。

SQLException

操作数据库出现了异常，这种异常属于 Checked Exception（检查异常）。

IOException

IO 异常通常与读写文件有密切关系，它属于 Checked Exception（检查异常）。在平时读写文件时，要记得关闭 IO 流。

NoSuchMethodException

方法未找到异常

NumberFormatException

字符串转换为数字异常

总结

这个总结采取了独特的方式，用几道经典的异常面试题来收尾吧，目的是帮助大家进行复习，哈哈。