你是正确的。

未经检查的异常用于让系统快速失效，这是一件好事。为了正常工作，你应该清楚地说明你的方法期望什么。通过这种方式，您可以只验证输入一次。

例如:

/**
 * @params operation - The operation to execute.
 * @throws IllegalArgumentException if the operation is "exit"
 */
 public final void execute( String operation ) {
     if( "exit".equals(operation)){
          throw new IllegalArgumentException("I told you not to...");
     }
     this.operation = operation; 
     .....  
 }
 private void secretCode(){
      // we perform the operation.
      // at this point the opreation was validated already.
      // so we don't worry that operation is "exit"
      .....  
 }

举个例子。关键是，如果系统快速失效，那么你就会知道它在哪里以及为什么会失效。你会得到这样的堆栈跟踪:

 IllegalArgumentException: I told you not to use "exit" 
 at some.package.AClass.execute(Aclass.java:5)
 at otherPackage.Otherlass.delegateTheWork(OtherClass.java:4569)
 ar ......

你会知道发生了什么。“delegateTheWork”方法中的OtherClass(在第4569行)使用“exit”值调用你的类，即使它不应该这样做等等。

否则你将不得不在你的代码中散布验证，这很容易出错。另外，有时很难跟踪哪里出了问题，可能会有几个小时令人沮丧的调试

同样的事情也发生在nullpointerexception中。如果你有一个700行的类，有15个方法，使用30个属性，它们都不能为空，而不是在每个方法中验证可为空性，你可以使所有这些属性都是只读的，并在构造函数或工厂方法中验证它们。

 public static MyClass createInstane( Object data1, Object data2 /* etc */ ){ 
      if( data1 == null ){ throw NullPointerException( "data1 cannot be null"); }

  }


  // the rest of the methods don't validate data1 anymore.
  public void method1(){ // don't worry, nothing is null 
      ....
  }
  public void method2(){ // don't worry, nothing is null 
      ....
  }
  public void method3(){ // don't worry, nothing is null 
      ....
  }

当程序员(你或你的同事)做的每件事都是正确的，验证输入，运行测试，所有的代码都是完美的，但代码连接到第三方web服务可能会关闭(或你正在使用的文件被另一个外部进程删除等)时，检查异常是有用的。web服务甚至可以在连接尝试之前进行验证，但是在数据传输过程中出错了。

在这种情况下，你或你的同事都无能为力。但你还是得做点什么，不能让应用程序在用户眼中消失。你使用一个检查异常来处理异常，当发生这种情况时你能做什么?，大多数时候，只是尝试记录错误，可能会保存你的工作(应用程序工作)，并向用户显示消息。(网站blabla宕机，请稍后重试)

如果检查过的异常被过度使用(通过在所有方法签名中添加“throw exception”)，那么您的代码将变得非常脆弱，因为每个人都会忽略这个异常(因为太普遍)，代码质量将严重受损。

如果过度使用未检查异常，也会发生类似的情况。这段代码的用户不知道是否会出现错误，因此进行了大量的尝试{…}catch(Throwable t)将出现。

你是正确的。

未经检查的异常用于让系统快速失效，这是一件好事。为了正常工作，你应该清楚地说明你的方法期望什么。通过这种方式，您可以只验证输入一次。

例如:

/**
 * @params operation - The operation to execute.
 * @throws IllegalArgumentException if the operation is "exit"
 */
 public final void execute( String operation ) {
     if( "exit".equals(operation)){
          throw new IllegalArgumentException("I told you not to...");
     }
     this.operation = operation; 
     .....  
 }
 private void secretCode(){
      // we perform the operation.
      // at this point the opreation was validated already.
      // so we don't worry that operation is "exit"
      .....  
 }

举个例子。关键是，如果系统快速失效，那么你就会知道它在哪里以及为什么会失效。你会得到这样的堆栈跟踪:

 IllegalArgumentException: I told you not to use "exit" 
 at some.package.AClass.execute(Aclass.java:5)
 at otherPackage.Otherlass.delegateTheWork(OtherClass.java:4569)
 ar ......

你会知道发生了什么。“delegateTheWork”方法中的OtherClass(在第4569行)使用“exit”值调用你的类，即使它不应该这样做等等。

否则你将不得不在你的代码中散布验证，这很容易出错。另外，有时很难跟踪哪里出了问题，可能会有几个小时令人沮丧的调试

同样的事情也发生在nullpointerexception中。如果你有一个700行的类，有15个方法，使用30个属性，它们都不能为空，而不是在每个方法中验证可为空性，你可以使所有这些属性都是只读的，并在构造函数或工厂方法中验证它们。

 public static MyClass createInstane( Object data1, Object data2 /* etc */ ){ 
      if( data1 == null ){ throw NullPointerException( "data1 cannot be null"); }

  }


  // the rest of the methods don't validate data1 anymore.
  public void method1(){ // don't worry, nothing is null 
      ....
  }
  public void method2(){ // don't worry, nothing is null 
      ....
  }
  public void method3(){ // don't worry, nothing is null 
      ....
  }

当程序员(你或你的同事)做的每件事都是正确的，验证输入，运行测试，所有的代码都是完美的，但代码连接到第三方web服务可能会关闭(或你正在使用的文件被另一个外部进程删除等)时，检查异常是有用的。web服务甚至可以在连接尝试之前进行验证，但是在数据传输过程中出错了。

在这种情况下，你或你的同事都无能为力。但你还是得做点什么，不能让应用程序在用户眼中消失。你使用一个检查异常来处理异常，当发生这种情况时你能做什么?，大多数时候，只是尝试记录错误，可能会保存你的工作(应用程序工作)，并向用户显示消息。(网站blabla宕机，请稍后重试)

如果检查过的异常被过度使用(通过在所有方法签名中添加“throw exception”)，那么您的代码将变得非常脆弱，因为每个人都会忽略这个异常(因为太普遍)，代码质量将严重受损。

如果过度使用未检查异常，也会发生类似的情况。这段代码的用户不知道是否会出现错误，因此进行了大量的尝试{…}catch(Throwable t)将出现。

在任何一个足够大的系统上，有很多层，检查异常是无用的，因为无论如何，您需要一个架构级策略来处理异常将如何处理(使用故障屏障)。

使用受控异常，您的错误处理策略是微管理的，在任何大型系统上都无法承受。

大多数情况下，您不知道错误是否“可恢复”，因为您不知道API的调用者位于哪一层。

假设我创建了一个StringToInt API，用于将整数的字符串表示形式转换为Int。如果API是用“foo”字符串调用的，我必须抛出检查异常吗?它可以恢复吗?我不知道，因为在他的层中，我的StringToInt API的调用者可能已经验证了输入，如果抛出这个异常，它要么是一个错误，要么是一个数据损坏，它是不可恢复的这一层。

在这种情况下，API的调用者不想捕获异常。他只想让异常“冒出来”。如果我选择了一个受控异常，这个调用者将有大量无用的catch块，只能人为地重新抛出异常。

大多数时候，什么是可恢复的取决于API的调用者，而不是API的编写者。API不应该使用受控异常，因为只有未受控异常才允许选择捕获或忽略异常。

受控异常非常好，只要你知道什么时候应该使用它们。对于SQLException(有时对于IOException)， Java核心API无法遵循这些规则，这就是它们如此糟糕的原因。

受控异常应该用于可预测的、但无法预防的、可以合理恢复的错误。

未检查异常应该用于其他所有事情。

我来解释一下，因为大多数人都误解了这句话的意思。

Predictable but unpreventable: The caller did everything within their power to validate the input parameters, but some condition outside their control has caused the operation to fail. For example, you try reading a file but someone deletes it between the time you check if it exists and the time the read operation begins. By declaring a checked exception, you are telling the caller to anticipate this failure. Reasonable to recover from: There is no point telling callers to anticipate exceptions that they cannot recover from. If a user attempts to read from an non-existing file, the caller can prompt them for a new filename. On the other hand, if the method fails due to a programming bug (invalid method arguments or buggy method implementation) there is nothing the application can do to fix the problem in mid-execution. The best it can do is log the problem and wait for the developer to fix it at a later time.

除非您抛出的异常满足上述所有条件，否则它应该使用未检查异常。

Reevaluate at every level: Sometimes the method catching the checked exception isn't the right place to handle the error. In that case, consider what is reasonable for your own callers. If the exception is predictable, unpreventable and reasonable for them to recover from then you should throw a checked exception yourself. If not, you should wrap the exception in an unchecked exception. If you follow this rule you will find yourself converting checked exceptions to unchecked exceptions and vice versa depending on what layer you are in.

对于已检查和未检查的异常，使用正确的抽象级别。例如，具有两种不同实现(数据库和文件系统)的代码存储库应该通过抛出SQLException或IOException来避免暴露特定于实现的细节。相反，它应该将异常包装在一个跨越所有实现的抽象中(例如RepositoryException)。

来自Java学习者:

When an exception occurs, you have to either catch and handle the exception, or tell compiler that you can't handle it by declaring that your method throws that exception, then the code that uses your method will have to handle that exception (even it also may choose to declare that it throws the exception if it can't handle it). Compiler will check that we have done one of the two things (catch, or declare). So these are called Checked exceptions. But Errors, and Runtime Exceptions are not checked for by compiler (even though you can choose to catch, or declare, it is not required). So, these two are called Unchecked exceptions. Errors are used to represent those conditions which occur outside the application, such as crash of the system. Runtime exceptions are usually occur by fault in the application logic. You can't do anything in these situations. When runtime exception occur, you have to re-write your program code. So, these are not checked by compiler. These runtime exceptions will uncover in development, and testing period. Then we have to refactor our code to remove these errors.

检查例外: 如果客户端可以从异常中恢复，并希望继续，请使用受控异常。

未经检查的异常: 如果客户端在异常发生后不能做任何事情，则引发未检查的异常。

示例:如果您希望在方法a()中执行算术操作，并且基于a()的输出，则必须执行另一个操作。如果方法A()的输出为空，而您在运行时并不期望它，那么您将抛出空指针异常，即运行时异常。

请参考这里