Advanced Programming Applications

Lecture 5
Exception and Java I/O

CCS2304
 Exceptions

Information includes: class name – line number – exception class

2
Exceptions Types

3
System Errors

4
Exceptions

5
Runtime Exceptions

6
Checked Exceptions vs Unchecked Exceptions

• RuntimeException, Error and their subclasses are known

as unchecked exceptions.

• All other exceptions are known as checked exceptions,

meaning that the compiler forces the programmer to
check and deal with the exceptions.

7
Unchecked Exceptions

8
 Unchecked Exceptions
• In most cases, unchecked exceptions reflect programming logic
errors that are not recoverable. For example,

• A NullPointerException is thrown if you access an object

through a reference variable before an object is assigned to it;

• An IndexOutOfBoundsException is thrown if you access an

element in an array outside the bounds of the array. These are
the logic errors that should be corrected in the program.
Unchecked exceptions can occur any where in the program.

• To avoid cumbersome overuse of try-catch blocks, Java

does not mandate you to write code to catch unchecked
exceptions.

9
 Exceptions Hierarchy

Exception Types

Unchecked Exception Checked Exception

could be unhandled by programmer should be handled by programmer

• Error and all its subclasses are unchecked exceptions.

• RunTimeException with all its subclasses are unchecked exceptions.
• Throwable, Exception and all its subclasses (except RunTimeException
and its subclasses) are checked exception.
10
 Why do we study exceptions?
• Handling Unchecked Exceptions
– Although not mandatory, handling these exceptions will
make your program reliable, robust and error prone.

• Handling checked Exceptions

– a lot of methods in the Java API throws checked Exceptions,
especially
o Methods that reads from file.
o Methods that connect your program to a remote P.C.
o Methods that connect your program to a database (Connection
and querying)

You must handle these exceptions to use these methods

11
The Catch or Specify Requirement
• Valid Java programming language code must honor the
Catch or Specify Requirement. This means that code that
might throw certain exceptions must been closed by
either of the following:
– A try statement that catches the exception. The try must
provide a handler for the exception.
– A method that specifies that it can throw the exception. The
method must provide a throws clause that lists the
exception.

12
Catch or Declare Checked Exceptions
• Java forces you to deal with checked exceptions. If a
method declares a checked exception (i.e., an exception
other than Error or RuntimeException), you must invoke
it in a try-catch block or declare to throw the exception
in the calling method.

• For example, suppose that method p1 invokes method

p2 and p2 may throw a checked exception (Ex:
IOException), you have to write the code as shown in (a)
or (b).

void p1() { void p1() throws IOException {

try { p2();
p2(); }
}
catch (IOException ex) { (b)
…
}
}
13
(a)
Catching Exceptions

14
 The General Form of an Exception-Handling Block
try{ class Exc2 {
// block of code to monitor for errors public static void main(String args[]) {
} int d, a;
catch(ExceptionType1 exOb) { try { // monitor a block of code.
// exception handler for ExceptionType1 d = 0;
} a = 42 / d;
catch(ExceptionType2 exOb) { System.out.println("This will not be printed.");
// exception handler for ExceptionType2 }
} catch (ArithmeticException e) {
// ... System.out.println("Division by zero.");
finally{ }
// block of code to be executed before System.out.println("After catch statement.");
try block ends }
} }

• When an Exception is caught the program is transferred automatically to

the appropriate catch block otherwise program stops.
• The goal of most well-constructed catch clauses should be to resolve the
exceptional condition and then continue as if the error had never happened.
• Finally, is always executed.

15
 Three Basic Rules for Exception-Handling
1- Multiple Catch Clauses void m(int i) {
int [] x = {1,4,0,2};
• After one catch statement executes, try {
the others are bypassed. int d = 4 / x[i]; }
• Exception subclasses must come before catch(ArrayIndexOutOfBoundsExceptione)
any of their superclasses, otherwise {//}
compile error. catch(ArithmeticExceptione)
{//}
2- Exception Propagation }

• If exception is not caught at its exact public static void main (String[] args) {
level , it propagates upwards towards ExcepDemo3 n = new ExcepDemo3();
the calling method. try {
• Exception can be caught at a higher n.m(3,0); }
level. catch(ArithmeticException e) {
//code to handle Exception}
}
}
void m(int x, int y) {
int z = x / y;
}

3- You can catch an exception using a reference of its super class 16

When do you use Exceptions
• When should you use the try-catch block in the code?
You should use it to deal with unexpected error
conditions. Do not use it to deal with simple, expected
situations. For example, the following code

try {
System.out.println(refVar.toString());
}
catch (NullPointerExceptionex) {
System.out.println("refVaris null");
}

17
 When do you use Exceptions
• It is better to be replaced by

if (refVar != null)
System.out.println(refVar.toString());
else
System.out.println("refVar is null");

18
Specifying the Exceptions Thrown by a Method

• Every method must state the types of checked

exceptions it might throw using the key word throws.
▪ Method throwing checked exception is mandatory to
declare it in method signature.
▪ Method throwing unchecked exception is optional to
declare it in method signature
The calling method for a method that declares to throw a checked
exception should
➢ surround the calling with try-catch
➢ or declare itself as throws,

19
Example: Handling The Exceptions from
method Integer.parseInt
Class Integer
public static int parseInt(String s) throws NumberFormatException
Parses the string argument as a signed decimal integer.
Throws: NumberFormatException. If the string does not contain a parsable
integer

Unchecked
Exception

Optional
try-catch

20
 Creating Object of scanner to read data from a file
public Scanner(File source) throws FileNotFoundException
Constructs a new Scanner. That produces values scanned from the specified file.
Parameters:
source - A file to be scanned
Throws:
FileNotFoundException – if source is not found.

Mandatory
try-catch
checked
Exception

public static void m1 (){

File data=new File("Data.db"); public static void m1 () throws FileNotFoundException{
try{ File data=new File("Data.db");
Scanner scan =new Scanner(data); Scanner scan =new Scanner(data);
} }
catch(FileNotFoundExceptione)
{ //code to handle Exception} 21
}
When to Throw Exceptions
• An exception occurs in a method.

• If you want the exception to be processed by its caller,

you should create an exception object and throw it.

• If you can handle the exception in the method where it

occurs, there is no need to throw it.

22
Throwing Exceptions
• When the program detects an error, the program can
create an instance of an appropriate exception type and
throw it. This is known as throwing an exception.
• Here is an example,

throw new TheException();

TheException ex = new TheException();

throw ex;

23
Throwing Exceptions Example
/** Set a new radius */
public void setRadius(double newRadius) throws
IllegalArgumentException {
if (newRadius >= 0)
radius = newRadius;
else
throw new IllegalArgumentException(
"Radius cannot be negative");
}

24
Throwing Exceptions Example
class Student {
private double GPA;
public void setGPA (double GPA) {
if (GPA > 4)
throw new IllegalArgumentException();
this.GPA = GPA;
} class Student {
} private double GPA;
public void setGPA (double GPA) throws Exception {
if (GPA > 4)
throw new Exception();
this.GPA = GPA;
}
}

• You can throw checked or unchecked exception using keyword throw

• Method that throws checked exceptions is mandatory to declare in its
signature using keyword throws.

25
 Declaring your own exceptions
class myException extends RuntimeException { import java.io.IOException
class myException extends I0Exception {
Unchecked Checked
Exception Exception

} }

Example

class GPAException extends RuntimeException { class Student {

private int GPA;
public void setGPA(int GPA) {
} if (GPA > 4)
throw new GPAException();
this.GPA = GPA;
}
}

26
Using Finally
• For each try-catch block there can be only one finally block.
• Case 1: If an exception is thrown with a matching catch block, then the
finally block is executed after the catch block and program continues.
• Case 2: If an exception does not happen the finally block will be
executed and program continues.
• Case 3: if an exception is thrown but not caught then the finally block
will be executed after the try block , then program stops.

try {
// statement 1 Case 1: statement 1 – statement 2 – statement 3 – statement 4
}

catch (exception e) { Case 2: statement 1 – statement 3 – statement 4

// statement 2
}

finally { Case 3: statement 1 – statement 3

// statement 3
}

// statement 4
27
Java I/O Processing

28
 Class File
• The File class in the java.io package represents
files.
– Create a File object to get information about a file on the
disk. (Creating a File object doesn't create a new file on your
disk)
File f = new File ("example.txt");
if (f.exists() && f.length() > 1000) {
f.delete();
}

29
The File Class
• To operate on a file, we must first create a File object
(from java.io.File).

30
Some File Methods

31
Class Scanner
• To read a file, create a File object and pass it as a parameter when
constructing a Scanner.
File f = new File("numbers.txt");
Scanner input = new Scanner(f);

32
Input Tokens
• token: A unit of user input. Tokens are separated by whitespace (spaces,
tabs, new lines).
• Example: If an input file contains the following:
23 3.14
John Smith
• The tokens in the input are the following, and can be interpreted as the
given types:
Token Type(s)
23 int, double, String
3.14 double, String
John String
Smith String

• Each call to next, nextInt, nextDouble, etc. advances the cursor to the
end of the current token, skipping over any whitespace.

33
 Reading Data using Class Scanner
• A Scanner breaks its input into tokens using whitespace. (spaces,
tabs, new lines).
• The resulting tokens may then be converted into values of
different types using the various methods.

File file = new File(“data.txt”); 23 3.14 5 Tokens

Scanner input=new Scanner(file); John Smith a
int i = input.nextInt();
double d = input.nextDouble();
String s1 = input.next();
String s2 = input.next();
char x = (input.next()).charAt(0);
34
Example

35
Example

36
 public float nextFloat()
• Scans the next token of the input as a float .
• This method will throw InputMismatchException if the next token
cannot be translated into a valid float value.
• If the translation is successful, the scanner advances past the
input that matched.
• If the next token matches the Float regular expression defined
above, then the token is converted into a float value.
Throws:
InputMismatchException – if the next token does not match the Float
regular expression, or is out of range
NoSuchElementException – if input is exhausted
IllegalStateException – if this scanner is closed

37
 Testing Before Reading
• The preceding program is impractical because it only processes
exactly 5 values from the input file.
– Typically, the actual program would read the entire file,
regardless of how many values it contains.
• Reminder: The Scanner has useful methods for testing to see
what the next input token will be:

Method Name Description

hasNext() whether any more tokens remain
hasNextDouble() whether the next token can be
interpreted as type double
hasNextInt() whether the next token can be
interpreted as type int
hasNextLine() whether any more lines remain

38
Example

39
Example

40
Example: Reading Data From File

41
Case Study

42
Case Study

43
 Writing Data Using PrintWriter
• First, you have to create a PrintWriter object for a text file as
follows:
– PrintWriter output = new PrintWriter(filename);

• If the given file does not exist, it is created.

• If the given file already exists, it will be truncated to zero size.
• Then, you can invoke the print, println, and printf methods on the PrintWriter
object to write data to a file.
• System.out is a standard PrintWriter Java object for the console.
• The close() method must be used to close the file. If this method is not invoked,
the data may not be saved properly in the file.

44
Any Questions?

45
 What is an Exception
• An exception is an unwanted or unexpected event, which occurs
during the execution of a program (i.e., at run time), that
disrupts the normal flow of the program’s instructions.

• Error vs Exception

Errors Exception
Represent serious and usually Exception indicates conditions
irrecoverable conditions like that a reasonable application
library incompatibility, infinite might try to catch.
recursion, or memory leaks.
- Exceptions are the problems
- Errors are generated to indicate which can occur at runtime and
errors generated by the runtime compile time. It mainly occurs in
environment. the code written by the
developers.
- Ex: JVM is out of memory.
Normally, programs cannot
recover from errors.

46
What is an Exception
• An exception can occur for many different reasons:
– A user has entered an invalid data.
– A file that needs to be opened cannot be found.
– A network connection has been lost in the middle of
communications.

47
Exception

Exception Class Type More info about the exception

48
Exception Solving

49
Exception

50
Exception Solving

51
Exception

52
Exception Execution

53
Exception Execution

54
Exception Multicatch

55
Unknown Exception

Arrangement is important

56
Finally Block
• A finally block in Java can be used to put “cleanup” code
such as closing a file, closing connection, etc.

• A finally block is always get executed whether the

exception has occurred or not.

• Rule: for each try block there can be one or more catch
blocks, but only one finally block.

Do not executed due to

return keyword

57
Finally Block

58
Finally Block
N.B: The finally block will not be executed if the program exits
(either by calling System.exit() or by causing a fatal error that
causes the process to abort.

59
 Exception Handling
• There are three main categories of exceptional conditions:
– Checked exceptions (Compile-time exceptions)
– Unchecked exceptions (Runtime exceptions)
– Errors

• A checked exception is an exception that is checked (notified)

by the compiler at compilation-time, these are also called as
compile time exceptions. These exceptions cannot simply be
ignored, the programmer should take care of (handle) these
exceptions.

• An unchecked exception is an exception that occurs at the time

of execution. These are also called Runtime Exceptions. These
include programming bugs, such as logic errors or improper use
of an API. Runtime exceptions are ignored art the time of
compilation.

• Errors represent serious and usually irrecoverable conditions like

a library incompatibility, infinite recursion, or memory leaks.
60
Exception Hierarchy

61
Java.lang Package from API Documentation

62
 Difference Between Exception and Error
• Error and Exception both are subclasses of the java Throwable
class that belongs to java.lang package.

Basis of Exception Errors

Comparison
Type It can be classified into two categories All errors in Java are
(i.e., checked and unchecked). unchecked.
Occurrence It occurs at compile time or run time. It occurs at run time.

Causes It is mainly caused by the application It is mostly caused by the

itself. environment in which the
application is running.
Recoverable/Irr Exception can be recovered by using An error cannot be recovered,
ecoverable the try-catch block. should not try catch it.

63
 Exception (FileNotFoundException)

64
 Exception (Read File Contents)

We used a file (resource), so we should use

finally to safely close the file to prevent the
data from being lost.
65
Exception (Read File Contents)

66
Exception (Try-with-resources) (after v1.7)

Try-with-resources will automatically

close the resources.

More than one resource

67
 Exception (Throws)
2

Exception Propagation
(Exception propagators)

More than one exception

68
Exception (Throws)
Any method will call readFile method
should handle the throws exceptions
either by try-catch or using throws

69
Error
Recursion error
But we don’t figure out the problem yet

70
 throw keyword
• The “throw” keyword is used to create a custom exception or
error.

• The “throw” keyword in Java is used to explicitly throw an

exception from a method or any block of code. We can throw
either checked or unchecked exception.

71
throw keyword

Custom Exception

72
throw keyword

Same as previous example but we saved it inside reference

The calling method should perform try-catch

73
throw keyword

Compiler execution sequence

finally block is executed before the throw

74
Throw Vs Throws
throw throws

Used within a method (or Used with method (or constructor)

constructor) signature
Used to throw an exception explicitly Used to declare exceptions

Can only throw a single exception Can declare multiple exceptions

Followed by a throwable instance Followed by an exception class name

Cannot be used to propagate checked Can be used to propagate checked

exceptions by itself exceptions by itself

75
Exceptions

76
User-Defined Exception

checked Exception

Unchecked
Exception

77