Exceptions and throws

• Guideline: Use a checked exception for conditions client code can reasonably be expected to handle.
• Java requires that a method declare in a throws clause the exceptions that it may throw
• A method's throws clause indicates to client programmers what exceptions they may have to deal with when they invoke the method
• Only exceptions that will cause a method to complete abruptly should appear in its throws clause:
  
  

  // In file VirtualPerson.java
  class VirtualPerson {
      public void drinkCoffee(CoffeeCup cup)
          throws TooColdException,
          TemperatureException,
          UnusualTasteException {
          try {
              int i = (int) (Math.random() * 4.0);
              switch (i) {
              case 0:
                  throw new TooHotException();
              case 1:
                  throw new TooColdException();
              case 2:
                  throw new UnusualTasteException();
              default:
                  throw new TemperatureException();
              }
          }
          catch (TooHotException e) {
              System.out.println(
                  "This coffee is too hot.");
              // Customer will wait until it cools
              // to an acceptable temperature.
          }
      }
      //...
  }
  

• The calling method must either catch the exception or declare it in its own throws clause:
  
  

  // In file VirtualCafe.java
  class VirtualCafe {
      public static void serveCustomer(
          VirtualPerson cust, CoffeeCup cup)
          throws TemperatureException,
          UnusualTasteException {
          try {
              cust.drinkCoffee(cup);
          }
          catch (TooColdException e) {
              System.out.println(
                  "This coffee is too cold.");
              // Add more hot coffee...
          }
      }
  }
  

Checked versus Unchecked

• Only checked exceptions need appear in throws clauses
• Whether an exception is "checked" or "unchecked" is determined by its position in the hierarchy of throwable classes:
  
  

Exceptions In Your Face

• Placing an exception in a throws clause forces client programmers who invoke your method to deal with the exception, either by:
  • Catching it, or
  • Declaring it in their own throws clause
• Errors: For the JVM and Java API
• To make a checked exception, subclass Exception but not RuntimeException
• To make an unchecked exception, subclass RuntimeException
  
  

Why Checked Exceptions?

• From the JLS: "This compile-time checking for the presence of exception handlers is designed to reduce the number of exceptions which are not properly handled."
• If you are throwing an exception for an abnormal condition that you feel client programmers should consciously decide how to handle, throw a checked exception.
• Unchecked exceptions indicate software bugs.
• Precisely because unchecked exceptions usually represent software bugs, they often can't be handled somewhere with more context.