1. Is the above considered to be a checked exception? No The fact that you are handling an exception does not make it a Checked Exception if it is a RuntimeException.

2. Is RuntimeException an unchecked exception? Yes

Checked Exceptions are subclasses of java.lang.Exception Unchecked Exceptions are subclasses of java.lang.RuntimeException

抛出已检查异常的调用需要包含在try｛｝块中，或者在方法调用方的上级级别中进行处理。在这种情况下，当前方法必须声明它抛出所述异常，以便调用方可以做出适当的安排来处理异常。

希望这能有所帮助。

Q: should I bubble up the exact exception or mask it using Exception?

A： 是的，这是一个非常好的问题，也是重要的设计考虑因素。类Exception是一个非常通用的异常类，可用于包装内部低级别异常。你最好创建一个自定义的异常并将其包裹起来。但是，还有一个大的异常——永远不要混淆潜在的原始根本原因。例如，永远不要执行以下操作-

try {
     attemptLogin(userCredentials);
} catch (SQLException sqle) {
     throw new LoginFailureException("Cannot login!!"); //<-- Eat away original root cause, thus obscuring underlying problem.
}

相反，请执行以下操作：

try {
     attemptLogin(userCredentials);
} catch (SQLException sqle) {
     throw new LoginFailureException(sqle); //<-- Wrap original exception to pass on root cause upstairs!.
}

Eating away original root cause buries the actual cause beyond recovery is a nightmare for production support teams where all they are given access to is application logs and error messages. Although the latter is a better design but many people don t use it often because developers just fail to pass on the underlying message to caller. So make a firm note: Always pass on the actual exception back whether or not wrapped in any application specific exception.

在尝试捕获RuntimeExceptions时

RuntimeException作为一般规则，不应尝试捕获。它们通常是编程错误的信号，应该单独处理。相反，程序员应该在调用一些可能导致＜code＞RuntimeException＜/code＞的代码之前检查错误条件。例如：

try {
    setStatusMessage("Hello Mr. " + userObject.getName() + ", Welcome to my site!);
} catch (NullPointerException npe) {
   sendError("Sorry, your userObject was null. Please contact customer care.");
}

这是一种糟糕的编程实践。相反，应该像这样进行空检查-

if (userObject != null) {
    setStatusMessage("Hello Mr. " + userObject.getName() + ", Welome to my site!);
} else {
   sendError("Sorry, your userObject was null. Please contact customer care.");
}

但有时这种错误检查是昂贵的，比如数字格式，考虑一下-

try {
    String userAge = (String)request.getParameter("age");
    userObject.setAge(Integer.parseInt(strUserAge));
} catch (NumberFormatException npe) {
   sendError("Sorry, Age is supposed to be an Integer. Please try again.");
}

在这里，调用前的错误检查是不值得的，因为它本质上意味着在parseInt（）方法中复制所有字符串到整数的转换代码，并且如果由开发人员实现，则很容易出错。所以最好不要尝试接球。

因此，NullPointerException和NumberFormatExceptionRuntimeExceptions，捕获NullPointerException应该替换为优雅的null检查，而我建议显式捕获NumberFormatException，以避免可能引入容易出错的代码。

1.如果您对异常不确定，请检查API：

 java.lang.Object
 extended by java.lang.Throwable
  extended by java.lang.Exception
   extended by java.lang.RuntimeException  //<-NumberFormatException is a RuntimeException  
    extended by java.lang.IllegalArgumentException
     extended by java.lang.NumberFormatException

2.是的，还有每一个扩展它的例外。

3.没有必要捕获并抛出相同的异常。在这种情况下，您可以显示一个新的“文件”对话框。

4.FileNotFoundException＜em＞已经是检查的异常。

5.如果期望方法调用＜code＞someMethod＜/code＞来捕获异常，则可以抛出后者。它只是“传球”。它使用的一个例子是，如果你想把它扔到你自己的私有方法中，而在你的公共方法中处理异常。

一个很好的阅读是Oracle文档本身：http://download.oracle.com/javase/tutorial/essential/exceptions/runtime.html

为什么设计人员决定强制一个方法指定其范围内可以抛出的所有未捕获的已检查异常？方法可以抛出的任何异常都是该方法公共编程接口的一部分。那些调用方法的人必须知道方法可以抛出的异常，这样他们才能决定如何处理这些异常。这些异常与其参数和返回值一样，也是该方法编程接口的一部分。

下一个问题可能是：“如果记录一个方法的API（包括它可以抛出的异常）很好，为什么不也指定运行时异常呢？”运行时异常表示由编程问题引起的问题，因此，不能合理地期望API客户端代码从中恢复或以任何方式处理它们。这类问题包括算术异常，例如除以零；指针异常，例如试图通过null引用访问对象；以及索引异常，例如试图通过过大或过小的索引访问数组元素。

Java语言规范：

在throws子句中命名的已检查异常类是方法或构造函数的实现者和用户之间契约的一部分。

IMHO的底线是，可以捕获任何RuntimeException，但您不需要，事实上，实现也不需要维护抛出的相同未检查异常，因为这些异常不是合同的一部分。

1） 否，NumberFormatException是未选中的Exception。即使你发现了它（你不需要），因为它没有被检查。这是因为它是IllegalArgumentException的子类，而RuntimeException是其子类。

2） ＜code＞RuntimeException＜/code＞是所有未检查异常的根源。＜code＞RuntimeException＜/code＞的每个子类都未选中。除了错误（位于Throwable下）外，将检查所有其他异常和可抛出。

3/4）您可以提醒用户，他们选择了一个不存在的文件，并要求提供一个新文件。或者停止通知用户他们输入了无效的内容。

5） 抛出并捕获＜code＞异常＜/code＞是一种糟糕的做法。但更普遍的情况是，您可能会抛出其他异常，以便调用方可以决定如何处理它。例如，如果您编写了一个库来处理读取一些文件输入，而您的方法被传递了一个不存在的文件，则您不知道如何处理。来电者想再次询问还是退出？因此，您将Exception向上抛出，返回给调用者。

在许多情况下，由于程序员没有验证输入（在第一个问题中出现NumberFormatException的情况下），会出现未检查的异常。这就是为什么捕获它们是可选的，因为有更优雅的方法可以避免生成这些异常。

选中-很可能发生。签入编译时。

文件操作

未检查-由于数据错误。已签入运行时。

例如。。

String s = "abc";
Object o = s;
Integer i = (Integer) o;

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
    at Sample.main(Sample.java:9)

这里的异常是由于坏数据造成的，并且在编译时无法确定。

Runtime Exceptions : Runtime exceptions are referring to as unchecked exceptions. All other exceptions are checked exceptions, and they don t derive from java.lang.RuntimeException.

Checked Exceptions : A checked exception must be caught somewhere in your code. If you invoke a method that throws a checked exception but you don t catch the checked exception somewhere, your code will not compile. That s why they re called checked exceptions : the compiler checks to make sure that they re handled or declared.

Java API中的许多方法都会抛出已检查的异常，所以您经常会编写异常处理程序来处理未编写的方法所生成的异常。

被检查的异常在编译时由JVM及其相关资源（files/db/stream/socket等）进行检查。检查异常的动机是，在编译时，如果资源不可用，应用程序应该定义一种替代行为，以在catch/finaly块中处理此问题。

未检查的异常是纯粹的程序错误、错误计算、空数据，甚至业务逻辑中的故障都可能导致运行时异常。在代码中处理/捕获未检查的异常是非常好的。

解释摘自http://coder2design.com/java-interview-questions/

Java教程跟踪文章“描述https://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html“rel=”noreferrer“>未检查的异常-争议”（很抱歉在这篇文章中获得了所有基本信息，但是，嘿，基本信息有时是最好的）：

Here s the bottom line guideline: If a client can reasonably be expected to recover from an exception, make it a checked exception. If a client cannot do anything to recover from the exception, make it an unchecked exception

“抛出什么类型的异常”的核心是语义（在某种程度上），上面的引用提供了一个很好的指导（因此，我仍然对C#摆脱了检查异常的概念感到震惊，尤其是当Liskov认为它们有用时）。

剩下的就变得合乎逻辑了：编译器希望我明确地响应哪些异常？您希望客户端从中恢复的那些。

为了回答最后一个问题（其他问题似乎在上面得到了彻底的回答），“我应该冒泡出确切的异常还是使用exception来掩盖它？”

我想你的意思是这样的：

public void myMethod() throws Exception {
    // ... something that throws FileNotFoundException ...
}

否，请始终声明最精确的异常，或此类异常的列表。将方法声明为能够抛出的异常是方法和调用者之间契约的一部分。抛出“FileNotFoundException”意味着文件名可能无效并且找不到文件；调用方将需要智能地处理该问题。抛出异常意味着“嘿，sh*t发生了。处理。”这是一个非常糟糕的API。

在第一篇文章的评论中，有一些例子表明“throws＜code＞Exception＜/code＞”是一个有效且合理的声明，但对于您将要编写的大多数“＜code＞normal＜/code>”代码来说，情况并非如此。

我认为，对于使用外部库的开发人员来说，检查异常是一个很好的提醒，即在异常情况下，该库中的代码可能会出错。

他们为什么让异常冒出来？更快地处理错误不是更好吗？为什么要冒泡沫

例如，假设您有一个客户端-服务器应用程序，并且客户端请求了一些找不到的资源，或者在处理用户请求时服务器端可能发生了其他错误，那么服务器有责任告诉客户端他为什么得不到他请求的东西，以便在服务器端实现这一点，编写代码是为了使用throw关键字抛出异常，而不是吞下或处理它。如果服务器处理它/吞下它，那么就没有机会向客户端通知发生了什么错误。

注意：为了清楚地描述发生的错误类型，我们可以创建自己的Exception对象并将其抛出到客户端。

我只是想添加一些根本不使用已检查异常的理由。这不是一个完整的答案，但我觉得它确实回答了你的部分问题，并补充了许多其他答案。

每当涉及检查异常时，在方法签名中的某个地方就会有一个＜code＞throws CheckedException＜/code＞（＜code＞CheckedException＞可以是任何检查异常）。签名不会引发异常，引发异常是实现的一个方面。接口、方法签名、父类，所有这些都不应该依赖于它们的实现。这里使用的checked Exceptions（实际上是您必须在方法签名中声明＜code＞throws＜/code＞的事实）将您的高级接口与这些接口的实现绑定在一起。

让我给你举个例子。

让我们有一个像这样漂亮干净的界面

public interface IFoo {
    public void foo();
}

现在我们可以编写许多方法foo（）的实现，比如

public class Foo implements IFoo {
    @Override
    public void foo() {
        System.out.println("I don t throw and exception");
    }
}

Foo班非常好。现在让我们第一次尝试吧

public class Bar implements IFoo {
    @Override
    public void foo() {
        //I m using InterruptedExcepton because you probably heard about it somewhere. It s a checked exception. Any checked exception will work the same.
        throw new InterruptedException();
    }
}

此类Bar不会编译。由于InterruptedException是一个已检查的异常，您必须捕获它（在方法foo（）中使用try-catch），或者声明您正在抛出它（将＜code＞throws Interrupted exception

public class Bar implements IFoo {
    @Override
    public void foo() throws InterruptedException {
        throw new InterruptedException();
    }
}

这个类Bar也不会编译！Bar的方法foo（）并没有覆盖IFoo的方法foo（），因为它们的签名不同。我可以删除@Override注释，但我想针对接口IFoo编程，比如＜code＞IFoo foo，然后决定要使用哪个实现，比如foo=new Bar（）。如果Bar的方法foo（）没有覆盖IFoo的方法foo，当我执行＜code＞foo.foo（）时

要使Bar的＜code＞public void foo（）throws InterruptedException＜/code＞覆盖IFoo的＜code>public void foo（）＜/code>，我必须将＜code＞throws IntertruptedException＞添加到IFoo的方法签名中。然而，这将导致我的Foo类出现问题，因为它的Foo（）方法的签名与IFoo的方法签名不同。此外，如果我将＜code＞throws InterruptedException＜/code＞添加到Foo的方法Foo（）中，我会得到另一个错误，说明Foo的方式Foo（。