Docsity
Log inSign up
Docsity
Prepare for your exams
Prepare for your exams

Study with the several resources on Docsity

Earn points to download
Earn points to download

Earn points by helping other students or get them with a premium plan

Guidelines and tips
Guidelines and tips
Sell on Docsity
Sell on Docsity
Log inSign up

Prepare for your exams

Study with the several resources on Docsity

Find documents

Prepare for your exams with the study notes shared by other students like you on Docsity

Search Store documents

The best documents sold by students who completed their studies

Search through all study resources
Docsity AINEW

Summarize your documents, ask them questions, convert them into quizzes and concept maps

Explore questions

Clear up your doubts by reading the answers to questions asked by your fellow students

Earn points to download

Earn points by helping other students or get them with a premium plan

Share documents
download point icon20 Points

For each uploaded document

Answer questions
download point icon5 Points

For each given answer (max 1 per day)

All the ways to get free points
Get points immediately

Choose a premium plan with all the points you need

Study Opportunities

Choose your next study program

Get in touch with the best universities in the world. Search through thousands of universities and official partners

Community

Ask the community

Ask the community for help and clear up your study doubts

University Rankings

Discover the best universities in your country according to Docsity users

Free resources

Our save-the-student-ebooks!

Download our free guides on studying techniques, anxiety management strategies, and thesis advice from Docsity tutors

From our blog

Exams and Study
Go to the blog

Error Handling in Java: Exception Mechanism and Handling, Exams of Computer Science

University of Mary Washington (UWM)Computer Science

This document, presented in the context of a class taught by prof. Steven r. Lerman and dr. V. Judson harward, delves into error handling in java. The session focuses on the exception mechanism, exploring better and worse ways to handle errors. It covers error codes, exception handling using ejector seat, advantages of using exceptions, throwing and declaring exceptions, checked vs unchecked exceptions, creating exception instances, catching exceptions, and the throw/try/catch pattern. The document also covers catching exceptions up the call stack and not catching exceptions up the call stack, with examples in the context of a calculator application.

Typology: Exams

Pre 2010

Uploaded on 08/13/2009

koofers-user-1lm-1
koofers-user-1lm-1 🇺🇸

10 documents

1 / 15

Toggle sidebar

This page cannot be seen from the preview

Don't miss anything!

bg1
Introduction to Computation and Problem
Solving
Prof. Steven R. Lerman
and
Dr. V. Judson Harward
Class 25:
Class 25:
Error Handling in Java
Error Handling in Java
2
Goals
In this session we are going to explore
better and worse ways to handle errors.
In particular, we are going to learn about the
exception mechanism in Java.
After learning about exceptions, you are
going to rework a specialized editor
application to make the error handling
more user friendly and effective.
1
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff

Partial preview of the text

Download Error Handling in Java: Exception Mechanism and Handling and more Exams Computer Science in PDF only on Docsity!

Introduction to Computation and Problem

Solving

Prof. Steven R. Lerman

and

Dr. V. Judson Harward

Class 25:Class 25:

Error Handling in JavaError Handling in Java

Goals

In this session we are going to explore

better and worse ways to handle errors.

In particular, we are going to learn about the

exception mechanism in Java.

After learning about exceptions, you are

going to rework a specialized editor

application to make the error handling

more user friendly and effective.

3 Approaches to Error Handling

• The error code

• errno

The error flag in memory, cf. UNIX

Exceptions – the ejector seat

Using Error Codes

return ???;

double sum = 0.0;

for ( int i = 0; i < dArray.length; i++ )

sum += dArray[ i ];

return sum / dArray.length;

public static double average( double [] dArray )

if ( dArray.length == 0 )

Using Exceptions

Advantages:

stack).

using a variation of inheritance.

Now for the mechanism:

Can not be confused with a normal return.

Programmer has to work to ignore it.

Error can be dealt with anywhere (up the call

Error conditions can be intelligently grouped

Throwing an Exception

throws IllegalArgumentException

throw new IllegalArgumentException();

double sum = 0.0;

for ( int i = 0; i < dArray.length; i++ )

sum += dArray[ i ];

return sum / dArray.length;

public static double average( double [] dArray )

if ( dArray.length == 0 )

Declaring an Exception

throws

throws IllegalArgumentException

RuntimeException or

  • RuntimeException or Error are

called

  • IllegalArgumentException

If a method can throw an exception, you can always declare

the type of the exception in the header after the keyword

public static double average( double [] dArray )

The compiler requires you to declare the possible exception

throw if the exception class is not derived from

Error. These are called checked

exceptions (checked by the compiler).

Exceptions derived from

unchecked exceptions and their declaration is optional.

is actually unchecked.

as a

ArrayIndexOutOfBoundsException

NumberFormatException

Checked vs. Unchecked Exceptions

The distinction between checked and unchecked

exceptions is fairly arbitrary.

In principle, checked exceptions are those which you, the

programmer, are supposed to be able to fix at runtime, such

FileNotFoundException. Very often these are

generated in system code by user, not programmer, error.

Unchecked exceptions are supposed to be able to occur

anywhere (so hard to check for and to be the result of

programmer error (so the best way of handling them is to

fix the program). Good examples, NullPointerException

. Bad example,

, thrown e.g. by

Integer.parseInt(String s)

throw / try / catch Pattern

try { if ( error ) throw new MyException(); //skip futher execution

catch ( MyException e ) {

// handle exception e

catch( MyException2 e ) { ... } // optional

...

finally { // optional

... // always executed if present

//resume execution

Catching Exceptions, 2

• If there is no enclosing try block in the current

catch clause, then the Java Virtual Machine

goes hunting up the call stack for a matching

try/catch pair.

program "hangs" ).

method, or one with an appropriately typed

If the JVM can't find such a pair on the call

stack, the default behavior is to print out an

error message and halt the thread (the whole

program if a console app; otherwise the

Catching Exception Up the Call Stack

double a = 0.0;

try {

}

{

// do something about it

}

System.out.println( “Average = “ + a );

Not Catching Exception Up the Call Stack

double [] myDoubles = {... };

a = average( myDoubles );

catch ( IllegalArgumentException e )

import javax.swing.*;

public class BadArgument {

public static void main( String [] args ) { while ( true ) { String answer = JOptionPane.showInputDialog( "Enter an integer" ); int intAnswer = Integer.parseInt( answer ); // What happens if the user types %!Z$ if ( intAnswer == 42 ) break;

System.exit( 0 );

What an Exception Object Contains

  • All Exception objects implement a toString()
  • You can also retrieve the error message (the

String

method:

public String getMessage()

method that will print out the exception type and

the exception message, if any.

argument, if present) by using the

realization that the place you discover an error is

errors.

Exceptions and Error Handling

The Zen of error handling starts with the

almost never the place where you can fix it.

Older languages like C use the horrible kludge of

error codes and flags as we have seen.

C++ introduced exceptions into the C family.

But many programmers simply don’t test for

The Exception Strategy

The goal of using exceptions is to

split the problem of detecting

errors from the problem of

handling them.

Exceptions in the Calculator

From CalculatorController:doOp()

try { ...

case Calculator.I_DIV:

setAcc( model.div() );

break;

{ error(); }

switch( eT )

catch ( EmptyStackException e )

Exceptions in the Calculator, 4

  • Despite the fact that EmptyStackException

programmer error.

  • ArrayStack
  • CalculatorModel
  • CalculatorController can do

Error

state until the user clears it.

is an

unchecked exception, it is caused here by user error (not entering enough operands) not

doesn't know how to fix it so it throws it.

doesn't know how to fix it, so

it throws it.

Finally,

something about it so it catches the exception and puts the whole calculator into the

Exceptions and Inheritance

  • Since exceptions are instances of

A FileNotFoundException is a derived class of

IOException.

exception.

  • The stack is searched for the nearest catch

its superclasses.

classes, exception classes may use inheritance.

When an error is detected, you should create and

throw a new instance of an appropriate type of

statement matching the exception class or one of

Exception Inheritance Example

try

{ } { } { }

FileReader in = new FileReader( "MyFile.txt" ); // read file here

catch ( FileNotFoundException e )

// handle not finding the file (bad file name?)

catch ( IOException e )

// handle any other read error

BirthdayApp Exercise, 1

class.

Download Lecture25.zip from the class web site. These files implement a birthday list editor. Examine the classes in the 3 files: BirthdayApp : This is the application class with the main() method. BirthdayView : This is the combined view and controller

BirthdayModel : This class maintains the growing list of birthdays. Don't worry about the methods labelled "Related to MVC" towards the end of the file. They update the JList when a new birthday is added. Birthday : contains the name and date information.