14b exceptions
Upcoming SlideShare
Loading in...5
×
 

14b exceptions

on

  • 438 views

 

Statistics

Views

Total Views
438
Views on SlideShare
438
Embed Views
0

Actions

Likes
0
Downloads
8
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

14b exceptions 14b exceptions Presentation Transcript

  • Finally
    LIS4930 © PIC
    There are times when you want some code to run regardless of an exception – you want it to run no matter what!
    The finally block is where you put code that must run regardless of an exception.
    A finally block lets you put all your important cleanup code in one place instead of duplicating it like this:
    try {
    turnOvenOn( );
    x.bake( );
    turnOvenOff( );
    } catch(BakingException ex) {
    ex.printStackTrace();
    turnOvenOff( );
    }
    try {
    turnOvenOn( );
    x.bake( );
    } catch(BakingException ex) {
    ex.printStackTrace();
    } finally {
    turnOvenOff( );
    }
  • A Method Can Throw More Than One Exception
    LIS4930 © PIC
    public class Laundry {
    public void doLaundry( ) throws PantsException, ShoeException {
    // code that could throw either exception
    }
    }
    public class Foo {
    public void go( ) {
    Laundry laundry = new Laundry( );
    try {
    laundry.doLaundry( );
    } catch(PantsException ex) {
    // recovery code
    } catch(ShoeException ex) {
    // recovery code
    }
    }
    }
  • Exceptions Are Polymorphic
    LIS4930 © PIC
    Don’t forget Exceptions are objects so a ClothingException can be extended into ShirtExceptions, PantsExceptions, and DressExceptions. Therefore:
    1
    2
    You can DECLARE exceptions using a supertype of the exceptions you throw.
    You can CATCH exceptions using a supertype of the exception thrown.
    Just because you CAN catch everything with one big super polymorphic catch, doesn’t mean you SHOULD.
    Write a different catch block for each exception that you need to handle uniquely.
    Look at page 330 for an example of polymorphic exceptions
  • Catching Multiple Exceptions
    Multiple catch blocks must be ordered from smallest to biggest.
    You can’t put bigger baskets above smaller baskets.
    LIS4930 © PIC
    Don’t do this!
    try {
    laundry.doLaundry( )
    } catch (ClothingExceptionce) {
    // recovery code goes here
    } catch (ShoeException se ) {
    // recovery code goes here
    } catch (DressException de) {
    // recovery code goes here
    }
  • Paying It Forward
    LIS4930 © PIC
    If you don’t want to handle an exception you can just throw it yourself so that whomever calls YOU will have to handle the exception.
    If you call a risky method that does throw an exception, instead of you handling it, you can keep throwing it.
    public void foo( ) throws PantsException, ShoeException {
    // call risky method without a try/catch block
    laundry.doLaundry( );
    }
  • Ducking (by paying it forward) Only Delays the Inevitable
    LIS4930 © PIC
    public class Washer {
    Laundry laundry = new Laundry( );
    public void foo( ) throws ClothingException{
    laundry.doLaundry( );
    }
    public static void main(String[] args) throws ClothingException{
    Washer a = new Washer( );
    a.foo( );
    }
    }
    1
    2
    3
    4
    doLaundry( ) throws a ClothingException
    foo( ) ducks the exception
    main( ) ducks the exception
    The JVM shuts down
  • Handle or Declare!
    LIS4930 © PIC
    So now we’ve seen both ways to satisfy the compiler when you call a risky (exception-throwing) method.
    1
    2
    HANDLE – Wrap the risky call in a try/catch block
    DECLARE – duck it / pay it forward
    Let’s look at the sequencer to see how each method works.
  • Exception Rules
    LIS4930 © PIC
    1
    2
    3
    4
    You cannot have a catch or finally without a try
    You cannot put code between the try and the catch
    A try MUST be followed by either a catch or a finally
    A try with only a finally (no catch) must still declare the exception
    void go ( ) {
    Foof = new Foo( );
    f.foof( );
    catch(fooException ex) { }
    }
    try {
    x.doStuff( );
    } finally {
    // cleanup
    }
    try {
    x.doStuff( );
    }
    inty = 43;
    } catch (Exception ex ) { }
    void go ( ) throws FooException {
    try {
    x.doStuff( );
    } finally { }
    }
  • Familiar Example
    LIS4930 © PIC
    But, what about this?
    We now know what this means.
  • Input and Output
    The java.iopackage includes a rich collection of different classes to support I/O.
    Different classes provide different ways for programs to organize and retrieve data.
    Java programs do not communicate directly with external devices, instead they create a stream object to connect the program to the device. Each stream functions as a conduit that establishes a path for the data to flow between the program and the I/O device.
    LIS4930 © PIC
  • Streams
    Java supports several different streams for different purposes.
    LIS4930 © PIC
    Output Stream
    Executing Program
    File (on disk)
    Input Stream
    Executing Program
    File (on disk)
  • Stream Hierarchy
    LIS4930 © PIC
    Output Stream (abstract)
    Input Stream (abstract)
    FileOutputStream
    FileInputStream
    to write raw bytes
    to read raw bytes
    ObjectOutputStream
    ObjectInputStream
    to write whole objects
    to read whole objects
    FilterOutputStream
    FilterInputStream
    DataOutputStream
    DataInputStream
    to write primitive values
    to read primitive values
  • Using Streams
    Open the file for input, instantiating associated stream objects.
    Call read methods to retrieve part of or the entire stream’s content.
    Close the file/stream.
    LIS4930 © PIC
    Input Streams
    Output Streams
    Open the file for output, instantiating associated stream objects.
    Call read methods to write data into the stream.
    Close the file/stream.
  • DataInputStreams & DataOutputStreams
    LIS4930 © PIC
    FileOutputStream
    FileInputStream
    DataOutputStream
    DataInputStream
    Executing Program
    Executing Program
    File (on disk)
    File (on disk)
  • Text Files
    LIS4930 © PIC
    Input Stream
    Input Stream
    Output Stream
    Output Stream
    BufferedReader
    Writer
    Reader
    Executing Program
    Executing Program
    Executing Program
    Executing Program
    Reader
    Writer
    File (on disk)
    File (on disk)
    File (on disk)
    File (on disk)
    BufferedWriter
  • Familiar Example
    LIS4930 © PIC
    Now we know what this means
    What if we didn’t “duck” the exceptions?
  • Input and Output of Files
    LIS4930 © PIC
    Input Stream
    Input Stream
    Output Stream
    Use a FileReader/FileWriter objects as your “Reader” conduit.
    BufferedReader
    FileReader
    Executing Program
    Executing Program
    Executing Program
    FileReader
    FileWriter
    File (on disk)
    File (on disk)
    File (on disk)
    BufferedWriter