• If you detect an “exceptional” condition, you can throw an exception
• An exception is an object that contains relevant error info

• If the exception is not caught, your application terminates

• Therefore, there are lots of different exception classes
• Each exception class represents a different kind of problem
• The Java library defines hundreds of standard exception classes (see later for some examples)

• Try to compile your code, the compiler will tell you soon enough
• Alternatively, take a look in JavaDoc for a method call, and it will tell you the list of checked exception you have to catch

• See the JavaDoc for the FileWriter constructor
• You’ll see that it throws an IOException
• You MUST deal with this exception in your code (why?)

• Contains code that might cause an exception

• Zero or more
• Specify an exception class, to catch exception object
• Perform recovery code

• Will always be executed
• Perform tidy-up code

• try must be followed immediately by catch and/or finally

• Based on file I/O
  import java.io.*;
...
public static void demoSimpleExceptions() {
 PrintWriter out = null;
 try {
  out = new PrintWriter(new BufferedWriter(new FileWriter("Myfile.txt")));
  out.println("Hello world.");
  out.println("Thank you, and goodnight.");
 }
 catch (IOException ex) {
  System.err.println(ex.getMessage());
 }
 finally {
  if (out != null) {
   out.close();
  }
 }
}

• View code file.

• Represents specializations of general error conditions

• There are several subclasses of IOException

• It will catch that exception type, plus any subclasses

• When an exception occurs, the runtime examines the catch handlers in sequence, looking for a suitable handler
  try {
 ...
}
catch (FileNotFoundException ex) {
 ...
}
catch (IOException ex) {
 ...
}


• You must organize your catch handlers from specific to general
• Don’t catch Exception (this would also catch runtime exceptions)

• You’re writing a low-level library class
• Lots of checked exception might occur
• You could catch these exceptions in your code, but you wouldn’t know what to do in your catch handlers

• “I don’t know how to handle this, over to you”

• Tag the method with a throws clause
• Specify a comma-separated list of checked exception types that might emanate from your method
  void myMethod() throws CheckedExceptionType1, CheckedExceptionType2 ...{
 ...
}

• The compiler ensures the caller catches these exceptions

• You’re writing a low-level library class
• You want to catch the checked exception locally, to do some intermediate processing (e.g. log the exception)
• Lots of checked exceptions might occur
• You also want to force the caller to do “full” processing

• Define a catch handler
• Do some local processing
• Use the throw keyword, to rethrow the checked exception object
  try {
 ...
} catch (CheckedExceptionType1 ex) {
 ...
 throw ex;
}


• Add code to throw runtime exceptions, as indicated by the TODO comments
   // Give the employee a pay rise.
 public double payRise(double amount) {
  
  if (amount <= 0) {    String message = String.format("Pay rise %.2f rejected, must be positive.", amount);    throw new IllegalArgumentException(message);   } else if (retired) {    String message = String.format("Pay rise for %s rejected, employee is retired.", name);    throw new IllegalStateException(message);   } else {    salary += amount;    return salary;   }  }
• View code file.
• Then in UsingCompany.java, add try/catch logic to deal with these exceptions
  try {
... theCompany.giveEmployeePayRise(id, amount);
} catch (CompanyException ex) {
    System.out.printf("Company exception: %s [id %s].\n", ex.getMessage(), ex.getId());
    if (ex.getCause() != null) {
     System.out.printf(" Cause: %s.\n", ex.getCause());
    }
   }

• View code file.

• You can't give an employee a negative pay rise, not even in the current economic climate!
• You can't give a retired employee a pay rise
• You can give a non-retired employee a positive pay rise

• You can declare one or more objects in (), separated by ;
• The objects must implement java.lang.AutoCloseable
• The close() method is automatically closed after the try block
• Then any catch/finally code is executed
  try (resource1; resource2; resource3; ...)
{
} // close() methods called here, in reverse order

• Usages:
  • Guarantees resources are closed, neater that try/finally
  • Many classes in Java SE 7 now implement AutoCloseable
• Example:
  • See DemoTryWithResources.java

• Can cause duplication in catch-handler blocks

• Reduces duplication

• Can be limiting if you're rethrowing exceptions

• The Java SE 7 compiler analyzes the try block more thoroughly

• An error message
• The id of the employee that was being processed when the exception occurred
• An "inner exception" cause. This will enable a CompanyException object to encapsulate a lower-level technical exception object

public class CompanyException extends Exception {
 private static final long serialVersionUID = 1L;
 private String id;
 
 public CompanyException(String message) {
  super(message);
 }
 public CompanyException(String message, String id) {
  super(message);
  this.id = id;
 }
 public CompanyException(String message, Throwable cause, String id){
  super(message, cause);
  this.id = id;
 }
 public String getId() {
  return id;
 }
}


• Located in relevant packages (e.g. java.io, java.sql, etc)

• Define a class that extends Exception
• Define a string constructor, plus other constructors/methods
  public class MyDomainException extends Exception {
 private Date timestamp = new Date();
 int severity = 0;
 public MyDomainException(String message) {
  super(message);
 }
 public MyDomainException(String message, int severity) {
  super(message);
  this.severity = severity;
 }
 public MyDomainException(String message, Throwable cause, int severity) {
  super(message, cause);
  this.severity = severity;
 }
 ... // Getters for timestamp and severity
}

• View code file.

• Use the throw keyword
• Specify an exception object (typically a newly-created one)

• hireEmployee()
   // Hire employee (i.e. add to company).
 public void hireEmployee(Employee emp) throws CompanyException {
  
  String id = emp.getId();
  
  if (employees.containsKey(id)) {
   throw new CompanyException("Cannot add employee, duplicate id.", id);
  } else {
   employees.put(id, emp);
  }
 }

• View code file.
• fireEmployee()
   // Fire employee (i.e. remove employee from company).
 public void fireEmployee(String id) throws CompanyException {
  
  if (!employees.containsKey(id)) {
   throw new CompanyException("Cannot remove employee, id not recognized.", id);
  } else {
   employees.remove(id);
  }
 }

• View code file.
• retireEmployee()
   // Retire employee (but keep their info).
 public void retireEmployee(String id) throws CompanyException {
  
  Employee emp = employees.get(id);
  
  if (emp == null){
   throw new CompanyException("Cannot retire employee, id not recognized.", id);
  } else {
   emp.retire();
  }
 }

• View code file.
• giveEmployeePayRise()
   // Give employee a pay rise.
 public void giveEmployeePayRise(String id, double amount) throws CompanyException {
  
  Employee emp = employees.get(id);
  
  if (emp == null){
   throw new CompanyException("Cannot give employee a pay rise, id not recognized.", id);
  
  } else {
   
   try {
    emp.payRise(amount);
  
   } catch (IllegalArgumentException ex) {
    throw new CompanyException("Cannot give employee a payrise.", ex, id);
   } catch (IllegalStateException ex) {
    throw new CompanyException("Cannot give employee a payrise.", ex, id);
   }
  }
 }

• View code file.

• Performs run-time tests for preconditions and postconditions
  private static void testWithoutAsserts() {
  try {
    int tz1 = getTimeZoneWithoutAsserts(60);
    if (tz1 != 4) {
      System.out.println("Invalid timezone result: " + tz1);
    }
    int tz2 = getTimeZoneWithoutAsserts(200);
  } catch (IllegalArgumentException ex) {
    System.out.println(ex);
  }
}
private static int getTimeZoneWithoutAsserts(int longitude) {
  if (longitude < -180 || longitude >= 180) {
    throw new IllegalArgumentException("longitude " + longitude + " out of range");
  }
  return longitude / 15;
}
}

• View code file.

• assert is treated as a keyword

• You'll get a compiler error in Java 1.4 onwards
• The only way to avoid the compiler error is to explicitly tell the java compiler to treat source code as Java 1.3 syntax:
  javac -source 1.3 MyLegacyCode.java


• -ea Enables assertions for all classes (except system classes)
• -esa Enables assertions for system classes

• -da Disables assertions for all classes (except system classes)
• -dsa Disables assertions for system classes

• -ea and -da enable you to enable/disable assertions for particular classes and/or packages (and sub-packages)
• Example:
  java -ea:mypackage1 -ea:mypackage2 -da:mypackage1.SomeClass MyApp


• Retire -
     // Ensure employees can retire.
   aCompany.retireEmployee("2");
   Employee retiredEmp = aCompany.getEmployee("2");
   assert (retiredEmp != null) : "Could not get retired employee.";
   assert (retiredEmp.isRetired()) : "Employee retirement not recorded properly.";

• View code file.
• Fired -
     // Ensure employees can be fired.
   aCompany.fireEmployee("3");
   Employee firedEmp = aCompany.getEmployee("3");
   assert (firedEmp == null) : "Spuriously got fired employee.";

• View code file.
• Get employees-
     // Ensure we can get existing employees.
   Employee emp1 = aCompany.getEmployee("1");
   assert (emp1 != null) : "Could not get existing employee.";
   
   // Ensure we can't get non-existent employees.
   Employee noSuchEmp = aCompany.getEmployee("99");
   assert (noSuchEmp == null) : "Spuriously got non-existent employee.";

• View code file.