• Class 3 Review
• Exception Handling
• Errors
• IO Classes
• (break)
• Net Classes
• Packages
• Reference notes
• Copyright notices
• Sample Programs

• Radio buttons
• Events

Exception handling is built into the Java language via the try{..} catch{..} finally{..} statements and is intended to be used for types of processing situations that normally can be handled by the application in some meaningful way.

Certain methods can create exceptions. Whenever you reference one of these methods, you must enclose it in a try code-block. Then you must also code a catch code-block to process the exception. This code block will receive an exception object as a parameter and can perform whatever processing is necessary. Example:

..
try {
  File readFile = new File(sDir, sFile);
  DataInputStream dis = new DataInputStream( new FileInputStream(readFile) );
   ..
}
catch (Exception e) {
  statusField.setText(e.toString());
  ..
}

In the above code, either of the two statements inside the try block (or possibly further statements) could throw an exception. The catch block will be invoked in all of these cases and simply stores the exception text into a textfield. Additional processing can also be performed here.

Exception processing:

• exceptions not inherited from RunTimeException class must be caught or specified
• can be nested (ie a try code-block can contain a nested try code-block). In this case, the exception will be handled by the innermost nested block in which the exception occurs.
• there are different types of exceptions (all of which are extensions of the exception class which in turn is an extension of the throwable class). The catch statement can explicitly refer to a specific exception or to the generic exception: eg catch (IOException e) {...} OR catch (Exception e) {..}
• you can code multiple catch code-blocks for the same try block. In this way you can easily program specific actions for specific types of exceptions
• in cases where you want some specific processing to occur before leaving a method (irregardless of whether or not an exception occurred) you can use the finally statement. The statement(s) in this code block will always be executed before control passes from the method for processing related to a try block.. It must coded as part of the try structure and usually occurs after any necessary catch blocks. It will always be executed even if no exceptions occurred.
• if you do not want to process the exception, you should use the throw statement which will then pass the exception to the invoking method
• you can "throw" your own exceptions at any point in your code by creating a new instance of one of the existing exception classes (or using a new exception class) and then use the throw statement. If you do this, you must also list the exceptions in the method definition:

public void myMethod(int x, String fileName) throws ArithmeticException, IOException {
  if (x == 0)
    throw new ArithmeticException();

  if (fileName == null)
    throw new IOException();

 ..
}

Errors are another type of extension to the throwable class and are derived from the java.lang.Error class. They are used in situations for which there is normally not a simple recovery that the application can perform and still continue to execute. They are thus not usually handled by the application (although if you wish to handle them, use the same procedure as for exceptions).

The classes in the IO package can be used for manipulating data-streams and files and also performing operating system operations on files and directories. Due to security restrictions imposed on Applets (especially when running in a browser environment) these classes are mostly used by Java Applications.

• basic capabilities are provided by the abstract classes: InputStream, OutputStream
• classes which are based on these classes include:
• ByteArrayInputStream, ByteArrayOutputStream (used to stream data to/from memory array)
• FileInputStream, FileOutputStream (used to stream data to/from files)
• FilterInputStream, FilterOutputStream (used for buffered streaming)
• PipedInputStream, PipedOutputStream (used to provide streaming between two processes)
• SequenceInputStream (used to concatenate several input streams into one)
• StringBufferInputStream (used to stream from a string object)
• two interfaces, DataInput and DataOutput define a more detailed data-oriented stream management
• classes derived from these include:
• DataInputStream, DataOutputStream (provide data streaming)
• RandomAccessFile (provides input, output to the same file)
• Additional stream classes include:
• Printstream (provides print-oriented formatting capabilities)
• LineNumberInputStream (allows processing of line-oriented streams with line number access)
• PushbackInputStream (allows lookahed in a FilteredInputStream)
• StreamTokenizer (allows tokenizing of input stream as data is processed)
• FilenameFilter (used by FileDialog to filter directory entries)
• File class is used to perform operating system operations such as create, delete, renaming, etc of files and directories
• Related class is FileDialog

This package contains classes which allow a Java program to communicate, via tcpip protocol, with other machines and to process content received from those machines. Supported processing modes include:

• socket-level (sockets can be created at the client-side or server-side) using either datagrams or streams
• URL-level (primarily intended for http communicatioin) (includes URL, URLConnection, URLEncoder and URLStreamHandler classes)
• abstract - the SocketImpl class can be used as the basis for implementation of other tcpip protocols (such as telnet or ftp) at the class level
• content handling - provided by implementation of the abstract ContentHandler class and/or the ContentHandlerFactory interface)
• restrictions may exist when using these classes from Applets

Best example of using these classes is the HotJava browser.

The IO package contains the classes and interfaces for handling files, streams and operating system related operations (directory manipulation, etc)

The NET package contains the classes and interfaces which support tcpip networking by Java programs.

 The following table lists the exceptions thrown by the standard JDK classes:

The following table lists the Errors:

Java and JDK as referenced herein are protected by the following copyright notices:

(c) Copyright Sun Microsystems, Inc., 1992-1997. All rights reserved.

(c) Copyright IBM Corporation, 1996-1997. All rights reserved.

The JDK is based in part on the work of the Independent JPEG group.

The Java(tm) technology is owned and exclusively licensed by Sun Microsystems, Inc. Java(tm) is a trademark of Sun Microsystems, Inc. in the United States and other countries.

The JDK implementation used in this class is OS/2 version 1.0.2 and is used with permission of IBM Corporation. This use is governed by the terms and conditions specified in the beta license agreement provided by IBM Corporation.