在Java(或任何其他带有受控异常的语言)中，当创建您自己的异常类时，您如何决定它应该被检查还是未检查?

我的直觉是，在调用者可能能够以某种有效的方式恢复的情况下，将调用checked异常，而作为未检查的异常则更多地用于不可恢复的情况，但我对其他人的想法感兴趣。

我如何从Java 8 lambda内部抛出CHECKED异常，例如在流中使用?

换句话说，我想让代码像这样编译:

public List<Class> getClasses() throws ClassNotFoundException {     

    List<Class> classes = 
        Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
              .map(className -> Class.forName(className))
              .collect(Collectors.toList());                  
    return classes;
    }

这段代码无法编译，因为上面的Class.forName()方法会抛出ClassNotFoundException，该异常会被检查。

请注意，我不想将已检查异常包装在运行时异常中，并抛出已包装的未检查异常。我想抛出检查异常本身，而不向流添加丑陋的try/catch。

多年来，我一直无法得到以下问题的一个像样的答案:为什么一些开发人员如此反对受控异常?我有过无数次的对话，在博客上读过一些东西，读过Bruce Eckel说的话(我看到的第一个站出来反对他们的人)。

我目前正在编写一些新代码，并非常注意如何处理异常。我试图了解那些“我们不喜欢受控异常”的人的观点，但我仍然看不出来。

我的每一次谈话都以同样的问题结束。让我把它建立起来:

一般来说(从Java的设计方式来看)，

Error is for things that should never be caught (VM has a peanut allergy and someone dropped a jar of peanuts on it) RuntimeException is for things that the programmer did wrong (programmer walked off the end of an array) Exception (except RuntimeException) is for things that are out of the programmer's control (disk fills up while writing to the file system, file handle limit for the process has been reached and you cannot open any more files) Throwable is simply the parent of all of the exception types.

我听到的一个常见的说法是，如果发生了异常，那么所有开发人员要做的就是退出程序。

我听到的另一个常见论点是受控异常使得重构代码更加困难。

对于“我要做的就是退出”的参数，我说即使你退出了，你也需要显示一个合理的错误消息。如果你只是在处理错误上押注，那么当程序在没有明确说明原因的情况下退出时，你的用户不会太高兴。

对于“它使重构变得困难”的人群来说，这表明没有选择适当的抽象级别。与其声明方法抛出IOException，不如将IOException转换为更适合当前情况的异常。

我对用catch(Exception)(或在某些情况下用catch(Throwable)包装Main没有问题，以确保程序可以优雅地退出-但我总是捕获我需要的特定异常。这样做至少可以显示适当的错误消息。

人们从来不会回答的问题是:

如果抛出RuntimeException 子类代替异常 子类，你怎么知道 你应该去抓?

如果答案是catch Exception，那么您也在以与系统异常相同的方式处理程序员错误。在我看来这是不对的。

如果你捕获Throwable，那么你是在以同样的方式处理系统异常和虚拟机错误(等等)。在我看来这是不对的。

如果答案是您只捕获您知道抛出的异常，那么您如何知道抛出了哪些异常呢?当程序员X抛出一个新的异常而忘记捕获它时会发生什么?这对我来说似乎很危险。

我认为显示堆栈跟踪的程序是错误的。不喜欢受控异常的人不会有这种感觉吗?

所以，如果你不喜欢受控异常，你能解释一下为什么不，并回答没有得到回答的问题吗?

我不是在寻求什么时候使用这两种模型的建议，我想知道的是为什么人们从RuntimeException扩展，因为他们不喜欢从Exception扩展，和/或为什么他们捕获一个异常然后重新抛出一个RuntimeException，而不是将抛出添加到他们的方法中。我想了解不喜欢受控异常的动机。

约书亚·布洛赫在《有效的Java》中说过

为以下情况使用检查异常 可恢复条件和运行时 编程错误的例外 (第二版第58项)

看看我理解的对不对。

以下是我对受控异常的理解:

try{
    String userInput = //read in user input
    Long id = Long.parseLong(userInput);
}catch(NumberFormatException e){
    id = 0; //recover the situation by setting the id to 0
}

1. 上述异常是否被认为是受控异常?

2. RuntimeException是未检查的异常吗?

以下是我对未检查异常的理解:

try{
    File file = new File("my/file/path");
    FileInputStream fis = new FileInputStream(file);   
}catch(FileNotFoundException e){

//3. What should I do here?
    //Should I "throw new FileNotFoundException("File not found");"?
    //Should I log?
    //Or should I System.exit(0);?
}

4. 现在，上面的代码不能也是一个受控异常吗?我可以试着挽回这样的局面吗?我可以吗?(注:我的第三个问题在上面的陷阱里)

try{
    String filePath = //read in from user input file path
    File file = new File(filePath);
    FileInputStream fis = new FileInputStream(file);   
}catch(FileNotFoundException e){
    //Kindly prompt the user an error message
    //Somehow ask the user to re-enter the file path.
}

5. 人们为什么要这样做?

public void someMethod throws Exception{

}

为什么他们让异常冒出来?早点处理错误不是更好吗?为什么要冒出来?

6. 我是否应该冒泡出确切的异常或使用异常掩盖它?

以下是我的阅读资料

在Java中，什么时候应该创建检查异常，什么时候应该是运行时异常?

何时选择已检查异常和未检查异常