CISC 3115 — Lecture 4 — Exception-Handling

CISC 3115
Modern Programming Techniques
Lecture 4
Exception-Handling

Overview

Because bad things happen to even good programs!
- File opens fail
- Zero-length arrays are sent to methods for which a zero length makes no sense
  - zero length array has no maximum or minimum
  - trying to take the average of a zero length array results in a division by zero
- Inputting a customer id from a transaction file and not finding the id in the customer master file
A production-level program must be sufficiently robust to work past such situations
- i.e., they must be handled by the program
Modern languages handle such situations using a mechanism known as exception handling

Handling Exceptional Situations in the Absence of Exception Handling

To begin with, exception-handling means dealing with exceptional situation. Exceptional does not necessarily mean erroneous, though errors are a large part of that category. Exceptional mean 'outside the course of normal events'.

The Issue

Exceptional situations often arise as the result of making a call to a method and something happening in that method that is outside the usual stream of logic for the code. There are two main issues to be addressed in such a situation.

Being Notified of the Exceptional Situation

If, as mentioned above, the situation arises as a result of calling a method, there must be some way of having the method return some indication of the situation. In Java, however, the only line of communication from the callee back to the caller is via the return value.
- This means that the callee must somehow notify the caller through the return value of the issue
- This raises the problem of how to do this when the return type/value is meant to represent the result of a 'normal' calculation.
- Using this same means of communication requires either:
  - some special value of the return type is used to indicate the exceptional situation
  - some other return type is used that allows for both normal and exceptional situation communication

Processing the Exceptional Situation

Even if there is a clean way to notify the calling code of the situation, there now is the issue that there has to be two separate streams of logic: one handling the normal course of events, the other the exceptional situation.
- If nothing else, this results in a disruption of the flow of the code, affecting readability and understanding of the main logic.

All of the above is compounded by the fact that there may be more than one sort of exceptional situation, each with its own notification requirement as well as flow of logic.

Handling the Issue at the Point of Occurrence or Elsewhere

One typical approach is to immediately follow (or precede) the possibly offending code with logic to determine whether an error has or will occur
- In the case of averring the elements of an array, we check before the calculator whether the array is of size 0.
- In the case of file open, we might check before the open whether the file exists or not
- In the case of reading in a value of restricted range (e.g. a 0…100 grade), we check after the read that the value complies with the range.
- In the case of adding an element to an array of fixed capacity, we check before we perform the actual insertion whether the array has the capacity (physical space) for the additional element.
However, sometimes the offending code is in a different area of the program than where the 'repair' can be made.
- For example, the user might be prompted for a file name in main, but the file not actually opened until sometime later, within a called method.
  - In this case, the location of the repair would be in main where the user is prompted for the file name
- In such situations, the offending code location needs to somehow notify the location that can do the repair about the problem.

As mentioned before, Regardless of which entity becomes responsible for dealing with the error or exceptional situation, the resulting logic is a distraction and results in a break in the flow of normal processing.

Some Examples

We present several coding contexts in which an exception (often interpreted as an error) situation can occur, and show various ways of dealing with it in the absence of exception handling.

Calculating the Average of an Array

double average(int [] arr) {

	int total = 0;
	for (int i = 0; i < arr.length; i++)
		total += i;
	return (double)total / arr.length;
}

How would you handle the case where the array is of size 0?
Having an array of length 0 may or may not be an error, but it IS an exceptional situation in the sense that it cannot be averaged like other arrays
- Also, one may not immediately think of a 0-length array as not being an error and thus it may not come to mind when coding this method
  - An example of a non-erroneous situation: averaging an array containing days where a non-0 amount of rain fell that day, and no rain fell

Using a Trailer Value

// Uses a (special) trailer value 

import java.io.*;
import java.util.*;

public class Averager {
	public static void main(String [] args) throws Exception {
		int [] 
			arr1 = {1, 2, 3, 4},
			arr2 = {};

		doIt(arr1);
		System.out.println();
		doIt(arr2);
	}

	static void doIt(int [] arr) {
		System.out.println("The array: " + toString(arr));

		double d = average(arr);
		if (Double.isNaN(d))
			System.out.println("0-length array ... average couldn't be taken");
		else
			System.out.println("average: " + d);
	}
				
	static double average(int [] arr) {
		if (arr.length == 0) return Double.NaN;
		double total = 0;
		for (int i = 0; i < arr.length; i++) 
			total += arr[i];

		return (double)total/arr.length;
	}

	static String toString(int [] arr) {
		String result = "{";
		for (int i = 0; i < arr.length; i++)
			result += arr[i] + (i < arr.length-1 ? ", " : "");
		return result + "}";
	}
}

Notes

Unlike most primitives, double actually has Double.NaN — an acceptable trailer value for all situations, i.e., a value that represents the absence of a valid double.
- Double.NaN is a static variable of type double from the Double (wrapper) class in java.lang.
The average method checks for a 0-length array and returns this trailer value in that situation
- The average of the array is returned in the 'normal' case
- Again, in both situations a value of type double is returned.
The other primitives do not have such a 'universal' trailer value, though they may have a suitable trailer depending on the context; e.g. -1 for the index of an array or a grade in the range of 0…100.
Notice the processing of both the normal and exceptional situation requires the introduction of a conditional after the potentially 'offending' code. This conditional logic (and the subsequent two streams of logic for normal and exceptional processing) is distracting and disruptive to the understanding of the main (i.e., normal) flow of logic.

Using a Result Object

// Uses a 'result' object containing status of operation and value

import java.io.*;
import java.util.*;

public class Averager {
	static class Result {
		Result(double average, boolean wasSuccessful) {
			this.average = average;
			this.wasSuccessful = wasSuccessful;
		}
		Result(boolean b) {this(0, false);}
		Result(double average) {this(average, true;}
		public double average;
		public boolean wasSuccessful;
	}

	public static void main(String [] args) throws Exception {
		int [] 
			arr1 = {1, 2, 3, 4},
			arr2 = {};

		doIt(arr1);
		System.out.println();
		doIt(arr2);
	}

	static void doIt(int [] arr) {
		System.out.println("The array: " + toString(arr));

		Result result = average(arr);
		if (!result.wasSuccessful)
			System.out.println("0-length array ... average couldn't be taken");
		else
			System.out.println("average: " + result.average);
	}

	static Result average(int [] arr) {
		if (arr.length == 0) return new Result(false);
		double total = 0;
		for (int i = 0; i < arr.length; i++) 
			total += arr[i];

		return new Result((double)total / arr.length);
	}
				
	static String toString(int [] arr) {
		String result = "{";
		for (int i = 0; i < arr.length; i++)
			result += arr[i] + (i < arr.length-1 ? ", " : "");
		return result + "}";
	}
}

Notes

In this approach, we are effectively returning two pieces of data: the status of the operation, i.e., was the average able to be calculated, and, if so, the actual value of the average
The issue is that methods can only return one value; to get around this, we introduce a result or wrapper class, containing two instance variables: a boolean status and a double for the average.
- The term wrapper refers to the fact that the two values being returned are wrapped in this temporary, utility/service class (temporary in the sense that it's only being introduced because of the 'single value' method return restriction; utility in the sense that it serves a technical purpose (again, getting around the single value restriction) related to the language.
- Other languages allow values to be returned from a method through the parameters (e.g., C++). In such languages one would typically return one or both of these values via a parameter rather than using a result class.
- Using a result class in this fashion can be quite useful, to the extent that a Pair class is often provided by the language's predefined class library.
  - Clearly, such a class can be extended to as many values as desired; alternatively, one could make one or both of the values in the Pair class itself a Pair, slowing for as many (nested) values as desired. We'll revisit this later.
  - When we get to inheritance we will see how such a class can be used with arbitrary typed values. In our case, we created a 'custom' result class consisting of our required boolean and double values.
A bit more on the Result class … as mentioned above, this class is temporary class in that it is briefly used for the purpose of passing multiple return values back from a called method.
- This class is solely for the purpose of the Averager class, and thus, rather than cluttering our class space with another class name, we make it an nested class, i.e., a class defined within another class definition.
  - There are several types of nested classes; for the moment we restrict ourselves to one declared with static in the class header, and is called a static nested class
  - Such a class can be treated almost as if it were just another 'top-level' class (i.e., one not defined within any other)
    - The main reason for defining the class in this manner is to empasize its logical relation to the outer class
      - In our case, this relationship is that Result is a class used specificaly and only by Averager.
  - Assuming it is accessible from the outside (i.e., not declared private), the class is referred to as OuterClass.NestedClass, e.g., Averager.Result.
    - WIthin the class, the usual scoping rules apply, so the class is just referred to by its name, e.g. Result.
  - The instance variables of the Result class are declared public. Given the temporary and short-lived use of the object of this class (their use is basically limited to returning the values from the method), there is no real reason to 'make them bulletproof' or provide any real semantics via methods; all that is really needed is for the caller to be able to access the instance variables.
  - We do, however, provide constructors to make it easy to create the Result object. In the case of a result object, we typically have the usual workhorse constructor (that accepts all values and initializes them), and then one for the valid case and one for the invalid case.
- Again, notice the processing of both the normal and exceptional situation requires the introduction of a conditional after the potentially 'offending' code, and the checking of the result's status variable.

Using a Guard Method

// Uses a 'guard' (pre-condition) method -- similar to the hasXXXX methods of Scanner

import java.io.*;
import java.util.*;

public class Averager {
	public static void main(String [] args) throws Exception {
		int [] 
			arr1 = {1, 2, 3, 4},
			arr2 = {};

		doIt(arr1);
		System.out.println();
		doIt(arr2);
	}

	static void doIt(int [] arr) {
		System.out.println("The array: " + toString(arr));

		if (!hasAverage(arr)) 
			System.out.println("0-length array ... average couldn't be taken");
		else
			System.out.println("average: " + average(arr));
	}

	static boolean hasAverage(int [] arr) {return arr.length != 0;}

	static double average(int [] arr) {
		// if !hasAverage(arr) ...
		double total = 0;
		for (int i = 0; i < arr.length; i++) 
			total += arr[i];

		return (double)total / arr.length;
	}
				
	static String toString(int [] arr) {
		String result = "{";
		for (int i = 0; i < arr.length; i++)
			result += arr[i] + (i < arr.length-1 ? ", " : "");
		return result + "}";
	}
}

Notes

In this approach, a method is provided that allows one to check the validity/legality of the possibly offending code. Such a method is called a guard or pre-condition method.
- We had a similar situation on our Color of the Labs; the isValid method was used to check the validity of the Color object's instance variables before executing other methods which could fail if those variables were out of range.
- guard methods are usually pre-condition, i.e., they are used before calling some method or executing some code. On occasion however, they are sometime post-condition, i.e., called after the possibly offending code (C++'s I/O library has examples of this).
And, once again, notice the processing of both the normal and exceptional situation requires the introduction of a conditional after the potentially 'offending' code variable.

Using `null`

Using null is really just a special trailer value case. As null is a legal value for all object types, returning null is a way to indicate that something went wrong.

It could be the case that null is a legitimate return value for the code (and thus ineligible as a true trailer value); we'll ignore that situation.

The novelty here is that we are dealing with a primitive return type — double (had it been a String for example — which is an object — it would be more straightforward. We wouldn't expect to be able to use null for double and that is the secondary purpose of this approach: first, to show that null can act as a trailer value and secondly, that there is a way to bring the primitives into the world of objects, namely using the primitive type wrapper classes. We will have a lot more to say about them when we talk about inheritance, the class hierarchy and collections later on.

The main takeaway from this example should not be the Double/double sleight-of-hand; that will be presented later. Rather, it's the use of null as the trailer value of sorts, and that this is thus applicable to all situations using objects as the return value.

/// Uses null as the exceptional case indicator

import java.io.*;
import java.util.*;

public class Averager {
	public static void main(String [] args) throws Exception {
		int [] 
			arr1 = {1, 2, 3, 4},
			arr2 = {};

		doIt(arr1);
		System.out.println();
		doIt(arr2);
	}

	static void doIt(int [] arr) {
		System.out.println("The array: " + toString(arr));

		Double d = average(arr);
		if (d == null)
			System.out.println("0-length array ... average couldn't be taken");
		else
			System.out.println("average: " + d);
	}
				
	static Double average(int [] arr) {
		if (arr.length == 0) return null;
		double total = 0;
		for (int i = 0; i < arr.length; i++) 
			total += arr[i];

		return (double)total/arr.length;
	}

	static String toString(int [] arr) {
		String result = "{";
		for (int i = 0; i < arr.length; i++)
			result += arr[i] + (i < arr.length-1 ? ", " : "");
		return result + "}";
	}
}

Notes

For each primitive in Java, the is a corresponding class in java.lang: Integer, Double, Boolean, Character, etc.
- We will go into these classes in more detail in later lectures, for the moment, suffice it to say that these classes exist for the purpose of:
  - bridging the gap between primitive types and classes/objects
  - providing a repository for methods applicable to the primitive type, but unable to be defined as such (since primitives cannot be receivers).
Suffice it to say, for the moment, that a primitive type and its corresponding wrapper class are interchangeable
- This is not 100% true, but it will have to do for the moment.
To use null (which only works for objects), we use Double instead of double
- Anywhere we need the double the Double object is converted; again, this will be explained later.
And, once again, notice the processing of both the normal and exceptional situation requires the introduction of a conditional after the potentially 'offending' code variable.

Opening a File

Scanner keyboard = new Scanner(System.in);

System.out.print("File name? ");
String fname = keyboard.next();

Scanner scanner = new Scanner(new File(fname));

What if the file doesn't exist?
- How do we know that?
What if we want to use a method filePrint(String filename)?

Using a Guard Method … Local Code

import java.io.*;
import java.util.*;

public class FileOpener {
	public static void main(String [] args) throws Exception {
		Scanner keyboard = new Scanner(System.in);
		Scanner datafile = null;
		String filename;
		while (true) {
			System.out.print("filename? ");
			filename = keyboard.next();
			File file = new File(filename);
			if (file.exists()) {
				datafile = new Scanner(file);
				break;
			}
			else
				System.out.println("'" + filename + "' not found, try again!");
		}

		// ... and here we go
		System.out.println("=== "  + filename);
		System.out.println("-----------------");
		while (datafile.hasNextLine()) {
			String line = datafile.nextLine();
			System.out.println(line);
		}
	}
}

Notes

We employ the exists method of the File class to check that we will be able to open the file
Problem:
- we have to know of the existence of this guard method
- We still have the distraction of normal/exceptional logic at the point of the offending code
Notice the infinite loop and use of break; once we break out of the loop, wer're good too go

Using a Guard Method … Separate Method

import java.io.*;
import java.util.*;

public class FileOpener {
	public static void main(String [] args) throws Exception {
		Scanner keyboard = new Scanner(System.in);
		while (true) {
			System.out.print("filename? ");
			String filename = keyboard.next();
			if (filePrint(filename)) break;
			System.out.println("'" + filename + "' not found, try again!");
		}
	}

	static boolean filePrint(String filename) throws Exception {
		File file = new File(filename);
		if (!file.exists()) return false;
		Scanner scanner = new Scanner(file);

		while (scanner.hasNextLine()) {
			String line = scanner.nextLine();
			System.out.println(line);
		}
		return true;
	}
}

Notes

Basically the same except here, the logic is a bit more involved as it requires communication back from the file printing method to the caller (which is responsible for getting the filename from the keyboard).

Processing Possibly Corrupt Input Data

Suppose we had an application that read in student data which was subject to the following constraints:

names: must be alpha only, upper first character, rest all lower
assignments: scale of 1…10
project: A, B, C, D, or F
exams: scale of 0…100

class DataIntegrityChecker {
	public static void main(String [] args) {
		Scanner fileScanner = new Scanner(new File("data.text"));

		while (fileScanner.hasNext()) {
			String lastName = scanner.next();
			String lastName = scanner.next();

			int numAssignments = scanner.nextInt();
			for (int i = 1; i <= numAssignments; i++) {
				int assignment = scanner.nextInt();
				assignmentTotal += assignment;
			}

			String project = scanner.next();

			int midterm = scanner.nextInt();

			int finalExam = scanner.nextInt();
	}
}

How do we detect corrupt data and what should be done when corrupt data is detected?

A Smorgesbord of Approaches

class DataValidation {

	// Uses null
	public static String validateName(String name) {
		if (name.length() == 0) return null;
		if (!Character.isUpperCase(name.charAt(0))) return null;
		for (int i = 1; i < name.length(); i++)
			if (!Character.isLowerCase(name.charAt(i))) return null;
		return name;
	}

	// Uses trailer value (-1)
	public static int validateAssignment(int grade) {
		return grade >= 0 && grade <= 10 ? grade : -1;
	}

	// Uses result object	
	static class Result {
		Result(boolean isValid, String grade) {
			this.isValid = isValid;
			this.grade = grade;
		}
		Result(String grade) {this(true, grade);}
		Result(boolean isValid) {this(isValid, "");}

		public boolean isValid;
		public String grade;
	}

	public static Result validateProject(String grade) {
		return "ABCDF".indexOf(grade) >= 0 ? new Result(grade) : new Result(false);
	}

	// Uses guard method
	public static boolean validateExam(int grade) {
		return grade >= 0 && grade <= 100 ? true : false;
	}
}

import java.util.Scanner;
import java.io.File;
import java.io.FileNotFoundException;

class DataIntegrityChecker {
	public static void main(String [] args) throws FileNotFoundException {
		Scanner fileScanner = new Scanner(new File("../data.text"));

		int dataRecord = 0;

		while (fileScanner.hasNextLine()) {
			String line = fileScanner.nextLine().trim();
			if (line.length() == 0) continue;

			dataRecord++;

			Scanner lineScanner = new Scanner(line);

			String lastName = DataValidation.validateName(lineScanner.next());
			if (lastName == null) {
				error(dataRecord, "Invalid last name");
				continue;
			}

			String firstName = DataValidation.validateName(lineScanner.next());
			if (firstName == null) {
				error(dataRecord, "Invalid first name");
				continue;
			}

			int numAssignments = lineScanner.nextInt();
			boolean isInvalid = false;
			for (int i = 1; i <= numAssignments; i++) {
				int assignment = DataValidation.validateAssignment(lineScanner.nextInt());
				if (assignment == -1) {
					error(dataRecord, "Invalid assignment grade");
					isInvalid = true;
				}
			}
			if (isInvalid) continue;

			String project = lineScanner.next();
			DataValidation.Result result = DataValidation.validateProject(project);
			if (!result.isValid) {
				error(dataRecord, "Invalid project grade");
				continue;
			}

			int midterm = lineScanner.nextInt();
			if (!DataValidation.validateExam(midterm)) {
				error(dataRecord, "Invalid midterm grade");
				continue;
			}

			int finalExam = lineScanner.nextInt();
			if (!DataValidation.validateExam(finalExam)) {
				error(dataRecord, "Invalid final grade");
				continue;
			}

			System.out.println("#" + dataRecord + ": " + lastName + " " + firstName + " validated");
		}
	}

	private static void error(int dataRecord, String message) {
		System.out.println("*** In data record #" + dataRecord + ": " + message);
	}
}

Notes

Guards Methods Throughout

Guard methods are always applicable (pass the value to be checked, return true/false based on the validity); and thus using them makes the vakidation iterface uniform.

The same is true of result objects, but those (at least for now) require new classes be defined and logic specific to the form of the result object.

class DataValidation {

	// Uses guard methods throughout

	public static boolean validateName(String name) {
		if (name.length() == 0) return false;
		if (!Character.isUpperCase(name.charAt(0))) return false;
		for (int i = 1; i < name.length(); i++)
			if (!Character.isLowerCase(name.charAt(i))) return false;
		return true;
	}

	public static boolean validateAssignment(int grade) {
		return grade >= 0 && grade <= 10 ? true : false;
	}

	public static boolean validateProject(String grade) {
		return "ABCDF".indexOf(grade) >= 0 ? true : false;
	}

	// Uses guard method
	public static boolean validateExam(int grade) {
		return grade >= 0 && grade <= 100 ? true : false;
	}
}

import java.util.Scanner;
import java.io.File;
import java.io.FileNotFoundException;

class DataIntegrityChecker {
	public static void main(String [] args) throws FileNotFoundException {
		Scanner fileScanner = new Scanner(new File("../data.text"));

		int dataRecord = 0;

		recordReadLoop:
		while (fileScanner.hasNextLine()) {
			String line = fileScanner.nextLine().trim();
			if (line.length() == 0) continue;

			dataRecord++;

			Scanner lineScanner = new Scanner(line);

			String lastName = lineScanner.next();
			if (!DataValidation.validateName(lastName)) {
				error(dataRecord, "Invalid last name");
				continue;
			}

			String firstName = lineScanner.next();
			if (!DataValidation.validateName(firstName)) {
				error(dataRecord, "Invalid first name");
				continue;
			}

			int numAssignments = lineScanner.nextInt();
			boolean isInvalid = false;
			for (int i = 1; i <= numAssignments; i++) {
				int assignment = lineScanner.nextInt();
				if (!DataValidation.validateAssignment(assignment)) {
					error(dataRecord, "Invalid assignment grade");
					isInvalid = true;
				}
			}
			if (isInvalid) continue;

			String project = lineScanner.next();
			if (!DataValidation.validateProject(project)) {
				error(dataRecord, "Invalid midterm grade");
				continue;
			}

			int midterm = lineScanner.nextInt();
			if (!DataValidation.validateExam(midterm)) {
				error(dataRecord, "Invalid midterm grade");
				continue;
			}

			int finalExam = lineScanner.nextInt();
			if (!DataValidation.validateExam(finalExam)) {
				error(dataRecord, "Invalid final grade");
				continue;
			}

			System.out.println("#" + dataRecord + ": " + lastName + " " + firstName + " validated");
		}
	}

	private static void error(int dataRecord, String message) {
		System.out.println("*** In data record #" + dataRecord + ": " + message);
	}
}

Notes

Handling Errors and Exceptional Situations

There are several issues to concern ourselves with regard to handling exceptions, i.e., exceptional situations:

Detection
- The actual detection of the exception depends upon the exception itself: attempting to divide by zero, trying to find the minimum of an empty array, going outside the bounds of the array — are all different.
Notification
- As we discuss below, the detector of the exception is usually not in position to do anything about it; thus there must be a notification mechanism via which the code that WILL handle the exception is notified. Furthermore, the code to handle the exception often requires information ABOUT the nature of the exception.
Processing
- As alluded to above, we use the term exception handling to describe the actions performed in response to the exception.

Detection: Who Detects the Exception?

It is often (in fact usually) the case that the code that detects an exception is NOT the code that can make a decision as to what to do about the exception:
- A search method that looks for values in an array is passed a value it does not find
  - to begin with is this even an exceptional situation? ...
  - and even if it is, what can the method do about it?
- A method that calculates the average of an array is passed an array of length 0
  - this is clearly undefined, and thus we're pretty much safe to say it's an error....
  - but again, what should the method do?
- A method that loads an array from a file is passed a filename that doesn't exist
  - Again, this may be an error, or it may simply mean that the resulting array should be of size 0 (for example if we're running a student registration system for the first time and the master student list is empty because we haven't registered any students yet; or the file represents the sales for the day in a retail system, and the store was closed for a holiday and thus there was no sales file created for that day).
  - Regardless, what should the method do if the file is not there?

Processing: Who Should Handle the Exception?

As we've seen above, the exceptional situation typically can't be handled by the method that detects it — it does not possess sufficient context to know what to do.
Following this line of logic, the calling method, should have a better knowledge of what is happening in the application, is more qualified to decide what to do about the exception; and if not THAT method, then ITS caller, or the caller before that, ...
We thus see that the chain of responsibility for handling the exception should follow the run-time calling sequence.

Notification: The Detector Notifying the Handler

The method detecting the exception may (but probably won't) handle the exception; assuming it doesn't, it passes responsibility for the exception to its caller
The caller either handles the exception, or passes responsibility up to ITS caller...
This process is repeated until either the exception is handled, or main attempts to pass the exception upwards in which case the Java runtime takes over and produces a comprehensive, but heavily technical diagnostic message — useless to anyone but a Java programmer.

Detection

As mentioned originally, the nature of the error is different from situation to situation and is often dependent on the particular situation. It is up to the designer of the code to look for and detect the presence or imminence of an error/exception.
Once the exceptional situation is recognized, the detecting code 'announces' this fact by throwing an exception. This is done via the throw statement.

The `throw` Statement

The throw statement is the basic mechanism of exception notification. The detecting code for the most part has no idea who will handle the exception, thus the term throw is quite appropriate — i.e., it has no idea who will be catching the exception notification.
The code throwing the exception needs some way of notifying the eventual catcher of what sort of exception has occurred (small, simple, illustrative programs might contain a single type of exception; in real applications, there will typically be many different sorts of exceptions that can occur).
- For at least the moment, we will restrict ourselves to the 'standard', predefined Exception class
- Throwing an exception in this context entails creatinga new Exception object (new Exception), passing the constructor a string containing information about the nature of the error/exception (e.g., new Exception("capacity exceeded")).
- The above creation expression is placed into a throw statement:
```
if (size == capacity) throw new Exception("capacity exceeded");
				
```

Some more examples:

…
if (y == 0) throw new Exception("zero divide attempted")
z = x / y;

void double calcAverage(int [] arr, int n) {
	if (n == 0) throw new Exception("can't take average of 0-length array");
	…
}

Handling the Exception — the `try`/`catch` Block

As mentioned before, the notification chain follows the run-time call sequence
- The caller of the method throwing the exception is the first given the opportunity to handle the exception; then its caller, all the way back to main
  - The method that contains the actual throw could also catch the thrown exception; this occurs less frequently
    - If the method that throws the exception knows what to do in that event, it limits the need for throwing the exception
- The intent to handle an exception is indicated by placing the code from which the exception could originate in a try/catch block.
```
try {
	...
	contains code (or a call to a method) that may throw an exception
	...
} catch (declaration of a variable receiving the thrown expression (a reference variable of some 'exception' class) {
	...
	code handling the exception; the exception variable is in scope here
} catch (declaration of a variable receiving the thrown expression (a reference variable of some other 'exception' class) {
	...
	code handling the exception; the exception variable is in scope here
}
…
				
```
- When an exception is thrown within the try block, execution flow jumps to the first corresponding catch block/clause
- The exception class types are examined one-by-one in their order of appearance. The first one that matches has its block executed and then execution continues after the try/catch.
- Execution proceeds in a normal fashion within the catch block
  - Within the block, the value of the exception variable containing the thrown expression can be accessed
    - You can think of that variable as a parameter to the catch block.
- Upon exiting the catchblock, execution proceeds as normal with the next statement.
Usually, the try catch block surrounds code containing calls to methods that could generate exceptions; however occasionally, the try block contains the actual code generating the exception.
- i.e., the handling code is in the same method as the detecting code

Exception classes

Exception — subsumes ALL exception classes (will make more sense one we've covered inheritance)
IOException — some I/O operation caused an error
FileNotFoundException — self-explanatory; subsumed by IOException
NumberFormatException — trying to convert a string to a numeric, and the string contains non-numeric characters
NullPointerException — attempting to deference null (e.g., name.getFirst(), and name is null).
ArrayIndexOutOfBoundsException — self-explanatory
NoSuchElementException — attempting to access an element (for the moment of a Scanner) and there is no such element

Miscellaneous

try/catch blocks can be nested
remember the order of the exceptions listed in the catch blocks can make a difference

The Array Averager

// Uses exception handling

import java.io.*;
import java.util.*;

public class Averager {
	public static void main(String [] args) throws Exception {
		int [] 
			arr1 = {1, 2, 3, 4},
			arr2 = {};

		doIt(arr1);
		System.out.println();
		doIt(arr2);
	}

	static void doIt(int [] arr) {
		System.out.println("The array: " + toString(arr));

		try {
			System.out.println("average: " + average(arr));
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}

	static double average(int [] arr) throws Exception {
		if (arr.length == 0) throw new Exception("0-length array ... average couldn't be taken");
		double total = 0;
		for (int i = 0; i < arr.length; i++) 
			total += arr[i];

		return (double)total / arr.length;
	}
				
	static String toString(int [] arr) {
		String result = "{";
		for (int i = 0; i < arr.length; i++)
			result += arr[i] + (i < arr.length-1 ? ", " : "");
		return result + "}";
	}
}

The File Opener

// uses exception-handling
import java.io.*;
import java.util.*;

public class FileOpener {
	public static void main(String [] args) {
		Scanner keyboard = new Scanner(System.in);
		while (true) {
			try {
				System.out.print("filename? ");
				String filename = keyboard.next();
				filePrint(filename);
				break;
			} catch (Exception e) {
				System.out.println(e.getMessage());
			}
		}
	}

	static void filePrint(String filename) throws Exception {
		File file = new File(filename);	
		if (!file.exists()) throw new Exception("'" + filename + "' not found, try again!");
		Scanner scanner = new Scanner(new File(filename));

		while (scanner.hasNextLine()) {
			String line = scanner.nextLine();
			System.out.println(line);
		}
	}
}

The Bad Data Handler

class DataValidation {
	public static String validateName(String name) throws Exception {
		if (name.length() == 0) throw new Exception("0-length name");
		if (!Character.isUpperCase(name.charAt(0))) throw new Exception("Non-uppercase first letter");
		for (int i = 1; i < name.length(); i++)
			if (!Character.isLowerCase(name.charAt(i))) throw new Exception("Non-lowercase internal letter");
		return name;
	}

	public static int validateAssignment(int grade) throws Exception {
		if (grade < 0 || grade > 10) throw new Exception("Invalid assignment grade");
		return grade;
	}

	public static String validateProject(String grade) throws Exception {
		if ("ABCDF".indexOf(grade) < 0) throw new Exception("Invalid project grade");
		return grade;
	}

	public static Integer validateExam(int grade) throws Exception {
		if (grade < 0 || grade > 100) throw new Exception("Invalid exam grade");
		return grade;
	}
}

import java.util.Scanner;
import java.io.File;
import java.io.FileNotFoundException;

class DataIntegrityChecker {
	public static void main(String [] args) throws FileNotFoundException {
		Scanner fileScanner = new Scanner(new File("../data.text"));

		int dataRecord = 0;

		while (fileScanner.hasNext()) {
			String line = fileScanner.nextLine().trim();
			if (line.length() == 0) continue;

			dataRecord++;

			Scanner lineScanner = new Scanner(line);

			try {
				String lastName = DataValidation.validateName(lineScanner.next());
				String firstName = DataValidation.validateName(lineScanner.next());

				int numAssignments = lineScanner.nextInt();
				for (int i = 1; i <= numAssignments; i++) {
					int assignment = DataValidation.validateAssignment(lineScanner.nextInt());
				}

				String project = DataValidation.validateProject(lineScanner.next());

				int midterm = DataValidation.validateExam(lineScanner.nextInt());
				int finalExam = DataValidation.validateExam(lineScanner.nextInt());

				System.out.println("#" + dataRecord + ": " + lastName + " " + firstName + " validated");
			} catch (Exception e) {
				System.out.println("*** Exception ... In data record #" + dataRecord + ": " + e.getMessage());
			}
		}
	}
}

CISC 3115 Modern Programming Techniques Lecture 4 Exception-Handling

Overview

Handling Exceptional Situations in the Absence of Exception Handling

The Issue

Being Notified of the Exceptional Situation

Processing the Exceptional Situation

Handling the Issue at the Point of Occurrence or Elsewhere

Some Examples

Calculating the Average of an Array

Using a Trailer Value

Using a Result Object

Using a Guard Method

Using null

Opening a File

Using a Guard Method … Local Code

Using a Guard Method … Separate Method

Processing Possibly Corrupt Input Data

A Smorgesbord of Approaches

Guards Methods Throughout

Handling Errors and Exceptional Situations

Detection: Who Detects the Exception?

Processing: Who Should Handle the Exception?

Notification: The Detector Notifying the Handler

Detection

The throw Statement

Handling the Exception — the try/catch Block

Exception classes

Miscellaneous

The Array Averager

The File Opener

The Bad Data Handler

Files used in this Lecture

CISC 3115
Modern Programming Techniques
Lecture 4
Exception-Handling

Using `null`

The `throw` Statement

Handling the Exception — the `try`/`catch` Block