Write an app that reads Color objects from a file, prints them out (using the class' toString method, and invokes the isGrey, and lighter methods. OTOH, if the r, g, b value(s) were invalid, an appropriate error message should be printed, and none of the subsequent operations should be performed, and execution should proceed to the next set of values to be read in.

The Constructor

public Color(int r, int g, int b) {
	if (r < 0 || r  255 || g < 0 || …) ???????	// WHat do we do here?
	this.r = r;
	this.g = g;
	this.b = b;
}

The read Method

public static Color read(
	if (!scanner.hasNextInt()) return null;
	int r = scanner.nextInt();
	int g = scanner.nextInt();
	int b = scanner.nextInt();
	return new Color(r, g, b);		// may 'blow up' in constructor
}

The App

Color c = Color.read(scanner);

while (???) {
	if (???) {
		System.out.println(r);
		System.out.println(r.isGrey());
		System.out.println(r.lighter());
	}
	c = Color.read(scanner);
}

Handling Exceptional Situations

• Because bad / unexpected things happen to even good / well-written 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
  • And as shown above, corrupted objects
• 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

The Issue

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 (that we currently know about) from the callee back to the caller is via the return value.
  • Lets take as an example a square root method being passed a negative argument.
  • The callee must somehow notify the caller through the return value of the issue
    • the square root method must notify its caller that the calculation cannot be performed
  • this is a problem when the return type/value is meant to represent the result of a 'normal' calculation.
    • in the case of a square root, we COULD conceivably return a negative value (since square root methods typically return the positive root, so a negative return value could act as a sentinel (a trailer value is also a form of sentinel, in that case it signals the end of data).
    • but what if we have a second (boolean) argument that dictates whether the positive or negative root should be returned. In that situation, there are no legitimate sentinel values.
  • Using this same means of communication requires either:
    • some special value of the return type is used to indicate the exceptional situation
      • this is somewhat reminiscent of using null to signal the end of data in our read methods
    • 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.

    …
    double d = Math.sqrt(d2);	
    if ( the value of d is the special sentinel value) {
    	handle the situation of having sent a negative argument to sqrt
    	…
    }
    else {
    	'normal' situation
    	…
    }
    				

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 averaging the elements of an array, we check before the calculation 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
  • Similarly for an empty array, the populating of the array probably occurs further up the call chain from the averaging logic
  • In such situations, the offending code location needs to somehow notify the location that that is capable of performing the repair about the problem.

Some Examples

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
      • The situation is not erroneous as it is perfectly feasible to occur
      • However, it is still exceptional in that no average can be calculated (one might state the average is 0, but that cannot be determined from the standard calculation of the average

Using a Sentinel

// Uses a special trailer value  known as a sentinel

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 + "}";
	}
}

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 + "}";
	}
}

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 + "}";
	}
}

Using null

• 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 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 + "}";
	}
}

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 define and then invoke 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);
		}
	}
}

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;
	}
}

• This is because all the handling is being done in the 'local' context of the situation
• Think of a fire in the fire station, there probably is not an alarm box in the station — the firemen and equipment are all there already

Processing Possibly Corrupt Input Data

• 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 firstName = 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 a sentinel (-1)
	public static int validateAssignment(int grade) {
		return grade >= 0 && grade <= 10 ? grade : -1;
	}

	// Uses a 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 a 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());	// using null
			if (lastName == null) {
				error(dataRecord, "Invalid last name");
				continue;
			}

			String firstName = DataValidation.validateName(lineScanner.next());	// using null
			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());	// using -1 (sentinel)
				if (assignment == -1) {
					error(dataRecord, "Invalid assignment grade");
					isInvalid = true;
				}
			}
			if (isInvalid) continue;

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

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

			int finalExam = lineScanner.nextInt();
			if (!DataValidation.validateExam(finalExam)) {	// using guard method
				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);
	}
}

Guards Methods Throughout

• 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);
	}
}

Who Should Handle the Problem

class Student {
	…
	int [] getGrades() {return grades;}	
	…
	private int [] grades;
}

class PrintDeansListApp {
	public static void main(String [] args) {
		…:
		Student student = Student.read(scanner);
		while (student != null) {
			System.out.println(student + " is on dean's list: " + isOnDeansList(student.getGrades()));
			student = Student.read(scanner);
		}
	}

	public static boolean isOnDeansList(int [] grades) {
		double avg = average(grades);
		return avg >= 90;
	}

	public static double average(int [] a) {
		if (a.length == 0) ????;
		int sum = 0;
		for (int x : a)
			sum += x;
		return (double) sum / a.length;
	}
}

Handling Errors and 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 (at least in the sense that the usual average calculation that divides by the number of elements would result in a ZeroDivide 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 and is likely 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

• We thus see that the method detecting the exception probably won't handle the exception; assuming it doesn't, it passes responsibility for the exception to its caller
• The caller thus 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.

Exception-Handling in Java

Detection and Notification

• 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

The throws Clause

• Java requires that the programmer indicate when a method explicitly throws, or propagates an exception.
  • A method propagates an exception if it receives the thrown exception and elects not to handle it, i.e., it throws it further up the call chain.

  …
  void f() throws FileNotFoundException {
  	// no try/catch .. exception will be propgated up the call chain
  	…
  	g();
  	…
  }
  
  void g() throws FileNotFoundException {
  	…
  	Scanner sc = new Scanner(new File("somefile.text"));
  	…
  }
  	

Miscellaneous

• try/catch blocks can be nested
• remember the order of the exceptions listed in the catch blocks can make a difference
  • Exception categories are often hierarchical; a broader category must come after the narrower one in the catch sequence or it will handle the narrower one.

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());
			}
		}
	}
}

Files used in this Lecture