ExceptionHandlingArgPrinter.java |
package lectures.exceptions; import util.annotations.WebDocuments; /** * TRY-CATCH * * Finally, we see something new: the try-catch-finally statement. * * The code within the braces following "try" is called the try block. * * The code within the braces following "catch" is called the catch block. * * A catch block, like a method, takes parameters. However it takes a single * parameter whose type is an exception class. * * An exception class is a class whose instances represent * runtime errors and is the Java class Exception or a subclass of Exception. * * Different exception classes represent different kinds of errors. * * * The code within the braces following "finally" is called the finally block. * */ @WebDocuments({"Lectures/Exceptions.pptx", "Lectures/Exceptions.pdf", "Videos/Exceptions.avi"}) public class ExceptionHandlingArgPrinter { public static void main(String[] args) { try { // System.out.println ("Try block started"); /* * Put break point below */ System.out.println(args[0]); //put break point here // System.out.println ("Try block ended"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Did not specify the argument to be printed. Terminating program."); } finally { System.out.println ("Program terminates at time:" + System.currentTimeMillis()); } } } /** * TRY-CATCH * * Your next task is to understand the nature of a try-catch block. * * Uncomment the two printlns and put a break point where instructed. * * Debug-run the program without supplying an argument * and step-over the array access to follow the control flow. * * Look also at the console to understand the control flow. * * Repeat the two steps, but this time provide an argument. * * Answer the questions below based on the behavior you see. That is, * your answers should be consistent with the behavior. * * (T/F) If no statement in a try block results in a runtime error (exception), * then the catch block is *not* executed. * * (T/F) If no statement in a try block results in a runtime error, * then the finally block is *not* executed. * * (T/F) If some statement in a try block causes an exception of some type * (e.g. ArrayIndexOutOfBoundsException), then the program jumps to the * catch block that takes the exception (e.g. ArrayIndexOutOfBoundsException) * as an argument, abandoning the remaining statements in the try block. * * * (T/F) If some statement in a try block causes an exception of some type * then the finally block is *not* executed. * * (T/F) It is possible for a try block to be partially executed. * * (T/F) It is possible for the program to execute a catch block * without attempting execution of some statement in the corresponding * try block. * * Comment out the two lines of the catch block without commenting out the two * lines of the finally block. * * (T/F) It is possible for a try block to not have a corresponding catch block. * * Uncomment the catch lines and comment out the two lines of the finally block * without commenting out the two lines of the catch block. * * (T/F) It is possible for a try block to not have a corresponding finally block. * * Comment out both the catch and finally blocks. * * (T/F) A try block must have a corresponding catch or finally block. * * Restore the program to its original state. * * Look at the code again now that you understand it. * * (T/F) ExceptionHandlingArgPrinter is more inefficient than ArgPrinter since subscript * checking of args is done twice, once by the program and once by Java. * * (T/F) For programmers not interested in understanding the error behavior * of programs, ExceptionHandlingArgPrinter is more readable than SafeArgPrinter as * they can more easily find and hence ignore error handling code. * * Next Class LinesReaderAndPrinter * */