Exception Handling and Format output by e51r8Xi

VIEWS: 15 PAGES: 68

									Exception Handling
and Format output
              Midterm exam

• Date: Oct 31
• Content:
  Week 1 to Week 8
Format:
  Multiple choice
  Determine the results of the code
  Write simple code
               Introduction

• Exception – an indication of a problem that
  occurs during a program’s execution
• Exception handling – resolving exceptions that
  may occur so program can continue or
  terminate gracefully
• Exception handling enables programmers to
  create programs that are more robust and
  fault-tolerant
               Introduction

• Examples
  – ArrayIndexOutOfBoundsException – an
    attempt is made to access an element past the end
    of an array
  – NullPointerException – when a null
    reference is used where an object is expected
   Exception-Handling Overview

• Intermixing program logic with error-handling
  logic can make programs difficult to read,
  modify, maintain and debug
• Exception handling enables programmers to
  remove error-handling code from the “main
  line” of the program’s execution
• Improves clarity
• Enhances modifiability
   Example: Not Catching Exceptions
 String inputStr;
 int     age;


 inputStr = JOptionPane.showInputDialog(null, "Age:");
 age       = Integer.parseInt(inputStr);



Error message for invalid input
Exception in thread "main" java.lang.NumberFormatException: For
input string: "ten"
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at Week7.SimpleException.main(SimpleException.java:12)
                    Catching an Exception
        inputStr = JOptionPane.showInputDialog(null, "Age:");


        try {


 try        age = Integer.parseInt(inputStr);


        } catch (NumberFormatException e){


            JOptionPane.showMessageDialog(null, "’" + inputStr
catch           +   "‘ is invalid\n"
                +   "Please enter digits only");
        }
         Performance Tip

If the potential problems occur infrequently,
intermixing program and error-handling logic
can degrade a program’s performance, because
the program must perform (potentially
frequent) tests to determine whether the task
executed correctly and the next task can be
performed.
Try-catch: what does that mean?

 When an exception occurs, or is thrown, the
 normal sequence of flow is terminated. The
 exception-handling routine is then executed;
 we say the thrown exception is caught.
Try-catch: what does that mean?

• try block – encloses code that might throw
  an exception and the code that should not
  execute if an exception occurs
• Consists of keyword try followed by a block
  of code enclosed in curly braces
Try-catch: what does that mean?

• catch block – catches (i.e., receives) and
  handles an exception, contains:
   – Begins with keyword catch
   – Exception parameter in parentheses –
     exception parameter identifies the
     exception type and enables catch block to
     interact with caught exception object
   – Block of code in curly braces that executes
     when exception of proper type occurs
Try-catch: what does that mean?

• Matching catch block – the type of the
  exception parameter matches the thrown
  exception type exactly or is a superclass of it
• Uncaught exception – an exception that
  occurs for which there are no matching
  catch blocks
   – Cause program to terminate if program has
     only one thread; Otherwise only current
     thread is terminated and there may be
     adverse effects to the rest of the program
try-catch Control Flow
           try-catch Control Flow

• When an exception occurs:
   – try block terminates immediately
   – Program control transfers to first matching catch block
• After exception is handled:
   – Termination model of exception handling – program
     control does not return to the throw point because the
     try block has expired; Flow of control proceeds to the
     first statement after the last catch block
   – Resumption model of exception handling – program
     control resumes just after throw point
        try-catch Control Flow
• try statement – consists of try block and
  corresponding catch and/or finally blocks



   Logic errors can occur if you assume that
   after an exception is handled, control will
   return to the first statement after the throw
   point.
                   Tip

With exception handling, a program can
continue executing (rather than terminating)
after dealing with a problem. This helps
ensure the kind of robust applications that
contribute to what is called mission-critical
computing or business-critical computing.
                       Review

To catch an exception, code must be enclosed
in a
   a. throws block.
   b. catch block.
   c. try block.
   d. finally block.
                       Review

To catch an exception, code must be enclosed
in a
   a. throws block.
   b. catch block.
   c. try block.
   d. finally block.
                  Review

An uncaught exception:
a. is a possible exception that never actually occurs
   during the execution of the program.
b. is an exception that occurs for which the matching
   catch clause is empty.
c. is an exception that occurs for which there are no
   matching catch clauses.
d. is another term for a thrown exception
                  Review

An uncaught exception:
a. is a possible exception that never actually occurs
   during the execution of the program.
b. is an exception that occurs for which the matching
   catch clause is empty.
c. is an exception that occurs for which there are no
   matching catch clauses.
d. is another term for a thrown exception
            Getting Information

• There are two methods we can call to get
  information about the thrown exception:
    – getMessage
    – printStackTrace
try {
    . . .
} catch (NumberFormatException e){


    System.out.println(e.getMessage());
    e.printStackTrace();
}
printStackTrace, getStackTrace
        and getMessage
• Methods in class Throwable retrieve more
  information about an exception
  – printStackTrace – outputs stack trace to
    standard error stream
  – getStackTrace – retrieves stack trace
    information as an array of StackTraceElement
    objects; enables custom processing of the
    exception information
  – getMessage – returns the descriptive string
    stored in an exception
               Multiple catch Blocks
• A single try-catch statement can include multiple catch
  blocks, one for each type of exception.

   try {
       . . .
       age = Integer.parseInt(inputStr);
       // Asuming I have a file I/O here
       . . .
   } catch (NumberFormatException e){
       . . .
   } catch (FileNotFoundException file_error){
       . . .
   }
Multiple catch Control Flow
              The finally Block

• There are situations where we need to take
  certain actions regardless of whether an
  exception is thrown or not.
• We place statements that must be executed
  regardless of exceptions in the finally block.
try-catch-finally Control Flow
             Propagating Exceptions

• Instead of catching a thrown exception by using the
  try-catch statement, we can propagate the thrown
  exception back to the caller of our method.
• The method header includes the reserved word throws.

 public int getAge( ) throws NumberFormatException {
     . . .
     int age = Integer.parseInt(inputStr);
     . . .
     return age;
 }
             Throwing Exceptions
• We can write a method that throws an exception
  directly, i.e., this method is the origin of the exception.
• Use the throw reserved to create a new instance of the
  Exception or its subclasses.
• The method header includes the reserved word throws.

 public void doWork(int num) throws Exception {
     . . .
     if (num != val) throw new Exception("Invalid val");
     . . .
 }
Sample Call Sequence
              Exception Thrower

• When a method may throw an exception,
  either directly or indirectly, we call the method
  an exception thrower.

• Every exception thrower must be one of two
  types:
   – catcher.
   – propagator.
                   Review

Which of the following is not true regarding the
   throw point of an exception?
a. It specifies the point at which the exception
   must be handled.
b. It is the initial point at which the exception
   occurs.
c. It is specified as the top row of the method-
   call stack at the time the exception occurred.
d. All of the above statements are true.
                   Review

Which of the following is not true regarding the
   throw point of an exception?
a. It specifies the point at which the exception
   must be handled.
b. It is the initial point at which the exception
   occurs.
c. It is specified as the top row of the method-
   call stack at the time the exception occurred.
d. All of the above statements are true.
                   Review

Which of the following is not true regarding the
   throw point of an exception?
a. It specifies the point at which the exception
   must be handled.
b. It is the initial point at which the exception
   occurs.
c. It is specified as the top row of the method-
   call stack at the time the exception occurred.
d. All of the above statements are true.
           Review question

Which of the following statements is not true?
 a. Exception handling enables programmers to
 write robust and fault-tolerant programs.
 b. Exception handling can only catch the
 exception but cannot resolve the exception.
 c. Exception handling can resolve exceptions.
 d. The Java 2 Platform, Standard Edition,
 Version 1.4 introduced the new chained
 exception feature.
           Review question

Which of the following statements is not true?
 a. Exception handling enables programmers to
 write robust and fault-tolerant programs.
 b. Exception handling can only catch the
 exception but cannot resolve the exception.
 c. Exception handling can resolve exceptions.
 d. The Java 2 Platform, Standard Edition,
 Version 1.4 introduced the new chained
 exception feature.
               Debugging 101

• execute your Java program line by line
• examine the value of variables at different
  points in the program
How to do:
  set a breakpoint in your code so the debugger
  suspends execution (double-click in the gray margin on
  the left side of the editor )
  choose Run -> Debug As -> Java Applications
     Types of Exception Throwers

• An exception catcher is an exception thrower
  that includes a matching catch block for the
  thrown exception.
• An exception propagator does not contain a
  matching catch block.
• A method may be a catcher of one exception
  and a propagator of another.
      Using the throws Clause
• throws clause – specifies the exceptions a
  method may throws
  – Appears after method’s parameter list and before
    the method’s body
  – Contains a comma-separated list of exceptions
  – Exceptions can be thrown by statements in
    method’s body of by methods called in method’s
    body
  – Exceptions can be of types listed in throws clause
    or subclasses
When to Use Exception Handling

• Exception handling designed to process
  synchronous errors
• Synchronous errors – occur when a statement
  executes
• Asynchronous errors – occur in parallel with
  and independent of the program’s flow of
  control
       Java Exception Hierarchy
• All exceptions inherit either directly or indirectly from
  class Exception
• Exception classes form an inheritance hierarchy that
  can be extended
• Class Throwable, superclass of Exception
   – Only Throwable objects can be used with the
     exception-handling mechanism
   – Has two subclasses: Exception and Error
       • Class Exception and its subclasses represent exception
         situations that can occur in a Java program and that can be
         caught by the application
       • Class Error and its subclasses represent abnormal situations
         that could happen in the JVM – it is usually not possible for a
         program to recover from Errors
Portion of class Throwable’s
    inheritance hierarchy.
         Checked/Compiling vs.
        Unchecked/Running time
• There are two types of exceptions:
  – Checked/Compiling time
  – Unchecked/Run time
• A checked exception is an exception that is
  checked at compile time.
• All other exceptions are unchecked, or
  runtime, exceptions. As the name suggests,
  they are detected only at runtime.
         Different Handling Rules
• When calling a method that can throw
  checked exceptions
   – use the try-catch statement and place the call in
     the try block, or
   – modify the method header to include the
     appropriate throws clause.

• When calling a method that can throw
  runtime exceptions, it is optional to use the
  try-catch statement or modify the method
  header to include a throws clause.
Handling Checked/Compiling Exceptions
Handling Unchecked/Runtime Exceptions
       Java Exception Hierarchy
• Two categories of exceptions: checked and
  unchecked
• Checked exceptions
   – Exceptions that inherit from class Exception but
     not from RuntimeException
   – Compiler enforces a catch-or-declare requirement
   – Compiler checks each method call and method
     declaration to determine whether the method
     throws checked exceptions. If so, the compiler
     ensures that the checked exception is caught or is
     declared in a throws clause. If not caught or
     declared, compiler error occurs.
      Java Exception Hierarchy
• Unchecked exceptions
  – Inherit from class RuntimeException or
    class Error
  – Compiler does not check code to see if
    exception is caught or declared
  – If an unchecked exception occurs and is
    not caught, the program terminates or runs
    with unexpected results
  – Can typically be prevented by proper
    coding
      Java Exception Hierarchy

• catch block catches all exceptions of its type
  and subclasses of its type
• If there are multiple catch blocks that match
  a particular exception type, only the first
  matching catch block executes
• It makes sense to use a catch block of a
  superclass when all the catch blocks for that
  class’s subclasses will perform the same
  functionality
                           Outline

try
{
      statements
} // end try
catch ( AKindOfException exception1 )
{
   exception-handling statements
}
.
.
.
catch ( AnotherKindOfException exception2 )
{
   exception-handling statements
}
finally
{
   statements
}
                  Review

Exceptions can occur:
a. from the Java Virtual Machine.
b. through explicitly mentioned code in a try
   block.
c. through calls to other methods made in a try
   block.
d. All of the above.
                  Review

Exceptions can occur:
a. from the Java Virtual Machine.
b. through explicitly mentioned code in a try
   block.
c. through calls to other methods made in a try
   block.
d. All of the above.
                    Review

In the catch block below, what is nullPointerException?
   catch (NullPointerException nullPointerException )
   {
     System.err.println(“nullPointerException”);
   } // end catch
a. The type of the exception being caught.
b. The name of catch block’s exception parameter.
c. A finally block.
d. An exception handler.
                    Review

In the catch block below, what is nullPointerException?
   catch (NullPointerException nullPointerException )
   {
     System.err.println(“nullPointerException”);
   } // end catch
a. The type of the exception being caught.
b. The name of catch block’s exception parameter.
c. A finally block.
d. An exception handler.
Throwing Exceptions Using the throw
            Statement
• throw statement – used to throw exceptions
• Programmers can thrown exceptions
  themselves from a method if something has
  gone wrong
• throw statement consists of keyword throw
  followed by the exception object
        Rethrowing Exceptions

• Exceptions are rethrown when a catch block
  decides either that it cannot process the
  exception or that it can only partially process
  it
• Exception is deferred to outer try statement
• Exception is rethrown by using keyword
  throw followed by a reference to the
  exception object
            Stack Unwinding
• Stack unwinding – When an exception is
  thrown but not caught in a particular scope,
  the method-call stack is “unwound,” and an
  attempt is made to catch the exception in the
  next outer try block.
            Stack Unwinding
• When unwinding occurs:
  – The method in which the exception was not caught
    terminates
  – All local variables in that method go out of scope
  – Control returns to the statement that originally
    invoked the method – if a try block encloses the
    method call, an attempt is made to catch the
    exception.
 Declaring New Exception Types

• You can declare your own exception classes
  that are specific to the problems that can
  occur when another program uses your
  reusable classes
• New exception class must extend an existing
  exception class
 Declaring New Exception Types

• Typically contains only two constructors
  – One takes no arguments, passes a default
    exception messages to the superclass constructor
  – One that receives a customized exception message
    as a string and passes it to the superclass
    constructor
Preconditions and Postconditions

• Preconditions and postconditions are the
  states before and after a method’s execution
• Used to facilitate debugging and improve
  design
• You should state the preconditions and
  postconditions in a comment before the
  method declaration
Preconditions and Postconditions

• Preconditions
  – Condition that must be true when the method is
    invoked
  – Describe method parameters and any other
    expectations the method has about the current
    state of a program
  – If preconditions not met, method’s behavior is
    undefined
Preconditions and Postconditions

• Postconditions
  – Condition that is true after the method successfully
    returns
  – Describe the return value and any other side-
    effects the method may have
  – When calling a method, you may assume that a
    method fulfills all of its postconditions
                Assertions
• Assertions are conditions that should be true
  at a particular point in a method
• Help ensure a program’s validity by catching
  potential bugs
• Preconditions and Postconditions are two
  kinds of assertions
• Assertions can be stated as comments or
  assertions can be validated programmatically
  using the assert statement
                 Assertions

• The syntax for the assert statement is
      assert <boolean expression>;
  where <boolean expression> represents
  the condition that must be true if the code is
  working correctly.
• If the expression results in false, an
  AssertionError (a subclass of Error) is
  thrown.
             Sample Use #1
public double deposit(double amount) {
   double oldBalance = balance;
   balance += amount;
   assert balance > oldBalance;
}

public double withdraw(double amount) {
   double oldBalance = balance;
   balance -= amount;
   assert balance < oldBalance;
}
              Second Form

• The assert statement may also take the form:

     assert <boolean expression>: <expression>;

  where <expression> represents the value
  passed as an argument to the constructor of
  the AssertionError class. The value serves
  as the detailed message of a thrown
  exception.
              Sample Use #2
public double deposit(double amount) {

    double oldBalance = balance;

    balance += amount;

    assert balance > oldBalance :
       "Serious Error – balance did not " +
       " increase after deposit";
}
 Compiling Programs with Assertions

• Before Java 2 SDK 1.4, the word assert is a
  valid nonreserved identifier. In version 1.4
  and after, the word assert is treated as a
  regular identifier to ensure compatibility.
• To enable the assertion mechanism, compile
  the source file using

      javac –source 1.4 <source file>

								
To top