exception handling.doc

7/29/2019 Exception Handling.doc

1/86

- 1 - Dr. Yaos CS 214 Class Notes #2

Exception HandlingIn Java, the parent class dealing with errors and exceptions is Throwable, which has two majorsubclasses: Exception and Error. The Error class defines the internal system errors; whereas

the Exception class defines the errors caused by the program. In general, the exception handling

is to account for and manage the possible run-time errors which may be raised by the program.

For each block of statements that may raise an exception, an exception handling routine shouldbe coded. The basic syntax is:

try

{

........statements that may throw exceptions....

} // try

catch(Exception-type1 identifier)

{

........exception handling statements......

} // catch

catch (Exception-type2 identifier)

{

........exception handling statements......

}// catch

The primary operations involved in handling exceptions include:

1. Declare an exception -- using the key word throws; for example,public static void main(String []x) throws IOException

1. Throw an exception -- using the operatorthrow; for example,throw new Exception(......);

1. Catch and handle an exception -- using the try and catch block or blocks.

try { .........}catch(Exception1........)

{ ......}

catch(Exception2.......){......}

The Exception class (java.lang.Throwable) provides a set of methods to assist in the exception

handling. Listed below are some of them, followed by a program example.Method: public String getMessage()

Description: Returns the detailed error or exception message.

Method: public String toString()

Exception: Returns a brief description of the exception


2/86


Catch1.java

// Handling exceptionimport java.io.*;

public class Catch1

{

public static void main(String []x) throws IOException{

int k = 12;int n = 0;

try

{

// try to divide a number by 0;System.out.println(k / n);

System.out.println(k + n);

} // trycatch (Exception e)

{ System.err.println(e.toString());System.err.println(e.getMessage());

} // catch

System.out.println(Press any key to exit.);System.in.read();

} // main

} // Catch1

The output produced by the above program is:

java.lang.ArithmeticException: / by zero/ by zero

I/O Classes by CategoriesIn general, input and output are treated as a sequence of bytes or characters; hence, a stream. In

Java, all input and output operations are handled as streams, either as a stream of bytes or a

stream of characters. Java I/O classes are divided into byte stream classes and character

stream classes. Java I/O classes can be divided into two generations: JDK 1.0 and JDK 1.1.

The classjava.io.InputStream andjava.io.OutputStream are the two top byte stream classes,as shown in the following inheritance trees. By functionality, streams are categorized intostandard I/O streams and file I/O streams. Manipulation on byte streams is assumed to be

sequential. In order to manipulate file streams in a random fashion, the

java.io.RandomAccessFile class is used.

java.lang.Object java.lang.Object java.lang.Object

| | |


3/86


+-- InputStream +-- OutputStream +-- RandonAccessFile

To support stream operations, Java has several interfaces, including top level interfaces

DataInput, DataOutput, and sub-level interfaces ObjectInput, and ObjectOutput. For

example, the java.io.RandomAccessFile is derived directly rom java.lang.Object and implementsthe DataInput and DataOutput interfaces in order to support both reading and writing to a

random access file. A random access file is treated as a large array of bytes stored in the file

system.

Thejava.io.Reader andjava.io.Writer classes, introduced by JDK 1.1, are the two topcharacterstream classes. In addition, thejava.io.StreamTokenizer class takes an input stream

and parses it into "tokens", allowing the tokens to be read one at a time. The inheritance treesare:

java.lang.Object java.lang.Object java.lang.Object

| | |+--java.io.Reader +--java.io.Writer +-- java.io.StreamTokenizer

Java provides a rich set of stream classes for input and output operations. All these stream

classes are defined in java.io package and are categorized into byte streams and character

streams. The InputStream and OutputStream are the top classes of all byte stream

subclasses. Reader and Writer classes are the top classes for character stream subclasses. The

overall inheritance hierarchies are shown below.

Byte Stream Classes

java.io.InputStream

|

+-- ByteArrayInputStream+-- FileInputStream

+-- FilterInputStream

|+-- BufferedInputStream

+-- DataInputStream ------------------------------------->>>> DataInput+-- LineNumberInputStream

+-- PushBackInputStream+-- ObjectInputStream --------------------------------------->>>> ObjectInput+-- PipeInputStream

+-- SequenceInputStream+-- StringBufferInputStream

java.io.OutputStream

|

+-- ByteArrayOutputStream

+-- FileOutputStream


4/86


+-- FilterOutputStream

|

+-- BufferedOutputStream+-- DataOutputStream ------------------------------------->>>> DataOutput+-- PrintStream

+-- ObjectOutputStream -------------------------------------------->>>> ObjectOutput+-- PipeOutputStream

Character Stream Classes

java.io.Reader

|

+-- CharacterArrayReader

+-- InputStreamReader

|

+-- FileReader+-- FilterReader

|+-- PushBackReader

+-- StringReader

+-- PipeReader+-- BufferedReader

|

+-- LineNumberReader

java.io.Writer

|

+-- BufferedWriter

+-- CharacterArrayWriter+-- OutputStreamWriter

|

+-- FileWriter+-- FilterWriter

+-- PipeWriter

+-- PrintWriter

+-- StringWriter

java.io.File Class

In addition to byte stream classes and character stream classes, thejava.io.File class (deriveddirectly from java.lang.Object class) presents an abstract, system-independent view of

hierarchical pathnames. Hence, it is an abstract representation offile and directory pathnames.

An abstract pathname has two components:1. An optional system-dependent prefix string, such as a disk-drive specifier, "/" for the

UNIX root directory, or "\\" for a Win32 pathname.

2. A sequence of zero or more string names.

A pathname can be either an absolute path or a relative path to the currently directory.


5/86


In summary, the java.io package contains a collection of stream classes that support these

algorithms for reading and writing streams. These classes are divided into two class hierarchiesbased on the data type (either characters or bytes) on which they operate, as depicted by the

below figure. Other stream classes are also present to support special stream operations, such as

the RandomAccessFile class. A collection of interfaces are also found in thejava.io package inorder to standardize and ease file stream manipulations, such as file/directory path and object

serialization.

Reading File Streams

All file streams are automatically opened when created. You can close any stream explicitly by

calling its close() method. Otherwise, the garbage collector can implicitly close it. The characterand byte streams are all sequential access streams. In JDK 1.0, DataInputStream along with

FileInputStream is to read from a file -- these classes will raise a deprecation warning message.

DataInputStream myfile = new DataInputStream(new FileInputStream(file-path));

To eliminate the deprecation message, the BufferedReader and FileReader are recommended:BufferedReader infile = new BufferedReader(new FileReader(file-path));

The next program demonstrates how a file is opened for reading. It reads a line from the inputfile and displays counters for lowercase letters, uppercase letter, and spaces found in the input

line.

// CountChar.java

import java.io.*;

/**

* This program demonstrates: File input manipulation.* It counts and display the number of lowercase letters, the number of uppercase letters, and

* the number of spaces on each input line. A line number is also displayed.

* @author: Andy Yao, Ph.D.*/

public class CountChar{/**

* Sequential file access.

* If DataInputStream along with FileInputStream is used, a deprecation message will be raised.

* BufferedReader along with FileReader should be used to process the input file.* The input file is the program source code itself.

* @param upper is the counter for uppercase letters.

* @param lower is the counter for uppercase letters.* @param spaces is the counter for uppercase letters.

* @param linecnt keeps track of the line number.

*/public static void main(String []args) throws IOException

{

// DataInputStream infile; // deprecated

BufferedReader infile;


6/86


String line;

int upper, lower, spaces, k, linecnt = 0;

char c;try

{

//infile = new DataInputStream(new FileInputStream("employee.java")); // deprecatedinfile = new BufferedReader(new FileReader("employee.java"));// Call readLine() method to read a line from the input file stream.

while ((line = infile.readLine()) != null) // A null denotes the end of file condition is true.{

++linecnt; // The line count

upper = lower = spaces = 0;for (k=0; k < line.length(); ++k) // Step through the input line, character by character.

{

c = line.charAt(k); // get one character

if ((c >= 'a') && c = 'A') && c


7/86


Uppercase: 2 Lowercase: 8 Spaces: 7

4: Dave 38729.15 Programmer

Uppercase: 2 Lowercase: 12 Spaces: 6

The next program shows how to process input file stream and use StringTokenizer to split a line

into fields. Fields of the input lines are separated by spaces. It is a common practice that aninput file is processed as a sequence of bytes and read into a String object on line by line basis.

The input String then is processed using other utilities, such as StringTokenizer.

// ReadFile.java

import java.io.*;

import java.util.*;

/*** Demonstrates the file reading operation and the use of StringTokenizer.

* Reads the data file line by line and parses each line into tokens (fields).

* These tokens are saved in three separate String arrays.

* This program also calculates and displays the total salary of all employees.* Assumption: The input file is located under the current working directory.

* Listed below are two sample input lines:* Wesley 49287.52 Programmer

* Addison 38929.20 Analyst

* @author: Andy Yao, Ph.D.*/

public class ReadFile

{

static BufferedReader infile;static String line;

static int k = 0;

static String []name = new String[100];static String []title = new String[100];

static double []salary = new double[100];

public static void main(String []args)

{

try

{

infile = new BufferedReader(new FileReader("employee.dat"));

while ((line = infile.readLine()) != null)

{saveRec(line, k); // save the input line into 3 arrays.

++k;

} // while

infile.close();

} // try

catch (IOException x) {

System.err.println(x.toString());


8/86


System.exit(1);

} // catch

printRec(k); // Print the output} // main

// Using StringTokenizer to split a line into fields.static void saveRec(String s, int k)

{

// Split the line into fields.StringTokenizer record = new StringTokenizer(s);

name[k] = record.nextToken(); // name

// Covert the salary in String into double.

salary[k] = Double.valueOf(record.nextToken()).doubleValue();title[k] = record.nextToken();

} // saveRec

// Displays the records and the total salary for all employees.static void printRec(int size)

{double total = 0;

for (int k=0; k < size; ++k)

{total = total + salary[k];

System.out.println(name[k] + " " + title[k] + " " + salary[k]);

}

System.out.println("Total salary: " + total);} // printRec

} // ReadFile

The output generated by the above program,ReadFile.java, is:

Lynda Clerk 38726.89

Eva Programmer 49287.52

Ava Analyst 38929.2

Dave Programmer 38729.15

Total salary: 165672.76

The above program, ReadFile.java, uses thejava.io.BufferedReader class to process an input

file. Thejava.io.BufferedReader is directly derived form thejava.io.Reader abstract class:

+--java.io.Reader

|

+--java.io.BufferedReader


9/86


The java.io.BufferedReader has two constructors:

BufferedReader(Readerin);// Create a buffering character-input stream that uses a default-sized input buffer.

BufferedReader(Readerin, int size);

// Create a buffering character-input stream that uses an input buffer of the specifiedsize.

Listed below are some of the commonly usedjava.io.BufferedReader methods:

int read() ; // Read a single character. Return -1 at the end of the stream.String readLine(); // Read a line of text. Return a null at the end of the file.

long skip(long n);// Skip n characters.

boolean ready(); // Indicates whether this stream is ready to be read.

The parameter in to the BufferedReader constructors can be an object created from any

subclass of thejava.io.Reader class. In a general practice, we need a class which takes either a

file path or file descriptor to create a Reader stream object. Thejava.io.FileReader (see

inheritance tree below) has the following three constructors and can be used for such a purpose:

FileReader(String filepath); java.io.Reader FileReader(File file); |

FileReader(FileDescriptor fd); +--java.io.InputStreamReader

|+--java.io.FileReader

The general statements used to process a file stream using the java.io.BufferedReader are:

BufferedReader infile = new BufferedReader(new FileReader(.........));

String line;

while ((line = infile.readLine()) != null) // read a line...................

or

BufferedReader infile = new BufferedReader(new FileReader(.........));

int c;

while ((c = infile.read()) != -1) // read a character

...................

The next program uses the read() method to process the input file one character at a time. It is

essential that the value returned by the read() method must be converted into a character for

output. Replacing Statement A by String line; and Statement B by

while ((line = infile.readLine()) != null)

System.out.println(line);

will achieve the same goal and produce the same output.


10/86


ReadFile2.javaimport java.io.*;

/*** Demonstrates the file reading operation.

* This program displays a file by reads

* one character at a time.

*/public class ReadFile2 {


{BufferedReader infile;

int c; // Statement Atry{

infile = new BufferedReader

(new FileReader("employee.dat"));

/* read() returns the integer equivalence of

the input character or -1 when the end offile stream is reached. */

// Statement Bwhile ((c = infile.read()) != -1)

// covert to a character for outputSystem.out.print((char) c);

infile.close();

} // trycatch (IOException x)

{System.err.println(x.toString());System.exit(1);

} // catch

} // main} // ReadFile2

Writing File Streams

To process an output file stream (writing to a file), we, again, have many options. Presented in

this section are two different options. The first option is to use thejava.io.BufferedWriter andjava.io.FileWriter classes.

WriteFile.java


11/86


// Writing to a file stream using BufferedWriter and FileWriter classes.

import java.io.*;public class WriteFile{

public static void main(String []args) {

BufferedWriter outfile; // Line 5try

{

outfile = new BufferedWriter(new FileWriter("output1.dat")); // Line 8

outfile.write("Hello, world!"); // Line 9outfile.close();


{

System.err.println("Error: " + x.toString());System.exit(1);

} // catch} // main} // WriteFile

The second option is to use thejava.io.DataOutputStream and java.io.FileOutputStream,

andjava.io.File classes; i.e., modifying the above to replace Line 5 by

DataOutputStream outfile;

Line 8 by DataOutputStream outfile = new DataOutputStream(

new FileOutputStream(new File("output2.dat")));

and Line 9 by

outfile.writeBytes(Hello, world!);

Thejava.io.BufferedWriter class is derived directly from thejava.io.Writer abstract class andhas two constructors:

// Create a buffered character output stream that uses a buffer of the default size.

BufferedWriter(Writerout);

// Create a buffered character output stream, using an output buffer of the given size.BufferedWriter(Writerout, int size);

The parameter out can be an object created from any subclass of thejava.io.Writer class. In a

general practice, an object is created from the java.io.BufferedWriter file for this purpose.Three commonly usedjava.io.BufferedWriter methods are listed below.

void write(int c); // Write a single character.

void write(String str); // Write a string.void write(char[] buf); // Write an array of characters.

The inheritance tree and constructors for thejava.io.FileWriter class are listed below.FileWriter(String filepath); java.io.Writer

FileWriter(File file); |

FileWriter(FileDescriptor fd); +--java.io.OutputStreamWriter


12/86


FileWriter(String name, boolean append); |

+--java.io.FileWriter

If one of the first three constructors is used to create a FileWriter file stream object, a new file is

created, truncating the original file contents if the file exists. The last constructor may be used

to set the append flag to true, if it is so desired to keep the original file contents and to appendto the end of the existing file, as demonstrated by the following program,AppendFile.java.

AppendFile.java// Appending to an existing file stream.import java.io.*;

public class AppendFile {


BufferedWriter outfile;try {

// open a file for appending

outfile = new BufferedWriter

(new FileWriter("output1.dat", true));

outfile.write("A new line");outfile.close();

} // try

catch (IOException x) {

System.err.println(x.toString());System.exit(1);

} // catch

} // main

} // AppendFile

The following Java standalone application, SaveFile.java, saves the text lines entered by the user

in a TextArea object into a file stream. This program uses a Frame object as its container to holdGUI objects. Generally, an applet is a subclass derived from either thejava.applet.Applet class

orjava.swing.JApplet class; whereas a standalone application uses a Frame or JFrame class to

create a top-level container.

// SaveFile.java

import java.awt.*;

import java.awt.event.*;import java.io.*;

/*** This GUI based program saves the text entered in a TextArea to a file.

* The output file is under the current working directory.

* This is a standalone application, using Frame as the GUI container.*/

public class SaveFile extends Frame implements ActionListener

{TextArea inarea;

Button save;


{

SaveFile x = new SaveFile(); // create an instance

x.setSize(200, 250); // set the Frame sizex.setVisible(true); // make the Frame show

} // main


13/86


/*

* Tasks of the constructor are:

* sets up the frame title and Layout manager* creates a Button and a TextArea

* attach GUI objects to event listener

* adds the GUI objects to the Frame**/

public SaveFile() { // constructor

setTitle("File Output"); // set the Frame titlesetLayout(new GridLayout(2, 1));

inarea = new TextArea(10, 30);

add(inarea);

save = new Button("Save");save.addActionListener(this); // Register to the event listener

add(save);

} // constructor

public void actionPerformed(ActionEvent e) {

if (e.getSource() == save){

try

{// Statement A BufferedWriter outfile = new BufferedWriter(new FileWriter("output.dat"));// Statement B

// BufferedWriter outfile = new BufferedWriter(new FileWriter("output.dat", true));outfile.write(inarea.getText());

outfile.close();

inarea.setText("");} // try

catch (IOException x)

{System.err.println(x.toString());

System.exit(1);

} // catch

} // if} // actionPerformed

} // SaveFile

The Statement A can be replaced by the Statement B, if the original file contents need to be

saved; thus, appending to the file.

// BothIO.java


14/86


// This program combines both input and output operations.

import java.awt.*;

import java.awt.event.*;

import java.io.*;/**

* This GUI based program saves the text entered in a TextArea to a file.

* It also reads from a text file into a second TextArea, using* BufferedReader and FileReader classes.

* The input and output file are under the current working directory.

* This is a standalone application, using Frame as the GUI container.

*/public class BothIO extends Frame implements ActionListener

{

TextArea inarea, outarea;

Button save, read;/*

* Tasks of the constructor are:* sets up the frame title and Layout manager

* creates Buttons and TextAreas

* attach GUI objects to event listener* adds the GUI objects to the Frame

**/

public BothIO() // constructor

{setTitle("File Output"); // set the Frame title

setLayout(new GridLayout(2, 2));

inarea = new TextArea(10, 30);add(inarea);

save = new Button("Save");

save.addActionListener(this); // Register to the event listeneradd(save);

outarea = new TextArea(10, 30);

outarea.setEditable(false); // output only

add(outarea);read = new Button("Read");

read.addActionListener(this); // Register to the event listener

add(read);} // constructor

public static void main(String []args){

BothIO x = new BothIO(); // create an instance

x.setSize(200, 250); // set the Frame size

x.setVisible(true); // make the Frame show


15/86


} // main

public void actionPerformed(ActionEvent e) {String line;

if (e.getSource() == save)

{try

{ // write to a text file

FileOutputStream os = new FileOutputStream(new File("myOutput.dat"));

DataOutputStream outfile = new DataOutputStream(os);

outfile.writeBytes(inarea.getText());

outfile.close();

inarea.setText("");} // try

catch (IOException x)

{


} // catch} // if save

if (e.getSource() == read){try

{ // Read from a text file

BufferedReader infile = new BufferedReader(new FileReader("myOutput.dat"));

while ((line = infile.readLine()) != null)outarea.append(line + "\n");

infile.close();


{


} // catch

} // if read

} // actionPerformed} // BothIO

Random Access FileThejava.io.RandomAccessFile class supports the random file access:

public class RandomAccessFile extends Object implements DataOutput,

DataInput

Instances of thejava.io.RandAccessFile class support both reading from and writing to a

random access file. A random access file behaves like a large array of bytes stored in the file


16/86


system. There is a kind of cursor, or index into the implied array, called thefile pointer. Input

operations read bytes starting at the file pointer and advance the file pointer past the bytes read.

If the random access file is created in read/write mode, then output operations are also available.Output operations write bytes starting at the file pointer and advance the file pointer past the

bytes written. Output operations that write past the current end of the implied array cause the

array to be extended. The file pointer can be read by the getFilePointer() method and moved/setby the seek() method.

Thejava.io.RandomAccessFile class implements both the DataInput and DataOutputinterfaces and therefore can be used for both reading and writing. When creating an instance of

thejava.io.RandomAccessFile class, you must indicate whether you wish to read from the file,

write to the file, or both. For example, the following statement opens a random file for reading

new RandomAccessFile("myfile.txt", "r");The next statement opens the a file for both reading and writing:

new RandomAccessFile("myfile.txt", "rw");

After the file is opened, you can use the readXXX orwriteXXX methods to perform I/O on the

file. Thefile pointerindicates the current cursor or index location in the file. When the file is

first created, the file pointer is 0, indicating the beginning of the file. Calls to the readXXX and

writeXXX methods adjust the file pointer by the number of bytes read or written. The

RandomAccessFile class provides three methods for explicitly manipulating the file pointer.

skipBytes Moves the file pointer forward the specified number of bytes.

seek Positions the file pointer just before the specified byte.

getFilePointer Returns the current byte location of the file pointer.

To randomly access to a file, the RandomAccessFile class is used. This class provides the

methods for reading and writing a file at a specific location. To move the read/write header(pointer), the seek() method is used. A random-access file can be opened either for read-only or

for read/write. The next program Randomio.java illustrates the use of the RandonAccessFileclass and its methods to manipulate the file contents in a random fashion.

Method: public RandomAccessFile(String filename, String access-mode)

Description: The constructor which is used to instantiate a RandomAccessFile object.

filename the file path

access-mode: r for reading; rw for read/write.

Method: public long length()

Description: This method returns the size of the file in byte (long).

Method: public void seek(long where)

Description: It moves the read/write pointer to where.

Method: writeBytes(String s)

Description: This method writes s to the file.


17/86


Method: readLine()

Description: This method reads a line from the file and returns the line as a String. It returns anull when the end of file condition becomes true.

Method: public void close()

Description: This method is used to close the file.

The next program (RandomIO.java), displays the following lines on the monitor.

Hello, world

Hello, A New line

------- Final result ----

Hello, A New line

How wonderful

Hence, the file Random.DAT will contain two lines:Hello, A New line

How wonderful

// RandomIO.java

// Random file I/O operations

import java.io.*;

public class RandomIO

{

static String filename = "A:Random.DAT";


{

try

{

append("Hello, world\n");

showit();

update(7, "A New line\n");

showit();

append("How wonderful");

System.out.println("---- Final result ----");

showit();

} // try

catch(Exception x)


18/86


{


System.exit(1);

} // catch

} // main

static void append(String msg)

throws IOException

{ // append "msg" to the end of the file

RandomAccessFile myfile;

try

{

myfile = new RandomAccessFile(new File(filename), "rw");

myfile.seek(myfile.length());

myfile.writeBytes(msg);

myfile.close();

} // try

catch (Exception x)

{

System.err.println(x.toString());System.exit(1);

}

} // append

static void update(long where, String s) throws IOException

{ // Write "s" to the file at "where"

RandomAccessFile myfile;

try

{

myfile = new RandomAccessFile

(new File(filename), "rw");

if (where > myfile.length())

where = myfile.length();


19/86


myfile.seek(where);

myfile.writeBytes(s);

myfile.close();

} // try

catch (Exception x)

{


System.exit(1);

}

} // insert

static void showit() throws IOException

{ // Displays the file contentsRandomAccessFile myfile;

try

{

String line;

myfile = new RandomAccessFile

(new File(filename), "r");

while ((line = myfile.readLine()) != null)

System.out.println(line);myfile.close();

} // try

catch (Exception x)

{


System.exit(1);

}

} // showit

} // RandomIO


20/86


The java.io.File Class

The File class is an abstract representation of file and directory path name. User interfaces andoperating systems use system-dependent path name (a sequence of characters) to name files and

directories. The File class presents an abstract, system-independent view of hierarchical path

names. An abstract path name has two components:

? An optional system-dependent prefix string, such as C: as a disk-drive specifier, or /

for the UNIX root directory

? A sequence of string names

The conversion of a path name string to or from an abstract path name is system-dependent.When an abstract path name is converted into a path name string, each name is separated from

the next by a single copy of the default separator character. The default name-separator

character is defined by the system property file separator. When a path name string is converted

into an abstract path name, the names within it may be separated by the default name-separator

character or by any other name-separator character that is supported by the underlying system.

A path name, whether abstract or in string form, may be eitherabsolute orrelative. An absolutepath name is complete in that no other information is required in order to locate the file that it

denotes. A relative path name, in contrast, must be interpreted in terms of information taken

from some other path name. By default the classes in the java.io package always resolve relativepath names against the current working directory. This directory is named by the system

property user.dir, and is typically the directory in which the Java virtual machine was invoked.

Instances of thejava.io.File class are immutable; that is, once created, the abstract path namerepresented by ajava.io.File object will never change.

The following program, MyDir.java, displays the files and subdirectories of the current

directory. The list() method of thejava.io.File class is used to retrieve the file/directory list.

String[] list(); // return a list of file/directory names.

This program works like the DIR command in MS/DOS or the ls command in UNIX.

MyDir.java


21/86


// Using the java.io.File class to display files/directories

// under the current working directory.import java.io.*;

public class MyDir {


String []dirList;try

{ File mypath = new File("."); // current directory

dirList = mypath.list(); // get the file list

for (int k=0; k < dirList.length; ++k)

System.out.println(dirList[k]);} // try

catch(Exception e)

{e.printStackTrace();

System.exit(2);}} // main

} // MyDir

Let us modify the previous program, MyDir.java, to take the first command line argument as

the directory, instead of the current directory. The synopsis for running this program is:

MyDir2 DirectoryName

The modified program, MyDir2.java, is shown below.

MyDir2.java


22/86


// Using the java.io.File class to display files/directories

// under the directory specified as a command line argument.// Synopsis: MyDir2DirectoryName

import java.io.*;

public class MyDir2 {

public static void main(String []args) {String []dirList;

try{

if (args.length != 1) // expecting 1 command line argument

{

System.err.println("Please specify a directory");System.exit(1);

}

File mypath = new File(args[0]);

dirList = mypath.list(); // get the file/directory list

for (int k=0; k < dirList.length; ++k)System.out.println(dirList[k]);} // try

catch(Exception e)

{e.printStackTrace();

System.exit(2);

}

} // main} // MyDir2

Object SerializationThe term object serialization means (1) converting all attributes (states) of an object into a

sequence of bytes and (2) saving this sequence bytes into as an object stream. An object streamis not necessarily a file stream. Such a mechanism can thus be used to prepare an object for

transmission across networks and operating systems. The java.io.Serializable interface is

designed for such purposes and, thus, can be used to implement the object persistence and

portability. Data Persistence means that the lifetime of an object is not determined by whether

the program is running or that an object lives in between the invocation of programs, such as a

client application (an applet or a standalone application) and a server-side program (a servlet).

Data Portability means that objects can be retrieved by Java programs running under different

operating system or networking environment, as long as the data class is accessible.

The serializability of a class is done by implementing the java.io.Serializable interface.Subclasses of a serializable class are also serializable, too. The Serializable interface has no

methods or attributes (fields) and serves only to identify the semantics of being serializable. By

functionality, Java classes can be group into: User interface or driver classes and Data classes.The data classes are to represent the objects in interest and should be coded to have the ability to

be serialized. Thus, the syntax:


23/86


public class ClassName implements Serializable { ........ }

Classes that require special handling or operation for the object serialization and de-serializationwill need to implement the writeObject() and readObject() methods. The signatures of these

java.io.Serializable interface are:

void writeObject(java.io.ObjectOutputStream out);

void readObject(java.io.ObjectInputStream in);

In general practice, classes that need to ensure its objects can be serialized will simply include

the implements Serializable expression as shown above and will not need to specifically define

the Serializable.writeObject() orSerializeable.readObject() methods. It is essential to realize

that serialization is actually performed by special kind of stream objects, generally known asobject streams: ObjectOutputStream for serialization and ObjectInputStream for de-

serialization). The java.io.ObjectOutputStream.writeObject() and

java.io.ObjectInput.readObject() methods are used to actually serialize and de-serialize

objects. The writeObject() method is responsible for writing the state of the object for itsparticular class so that the readObject() method will be able to restore (deserialize) it. Thus,

object state is saved by writing the serializable attributes/fields to the

java.io.ObjectOutputStream object using the writeObject() method. Attributes declared as

static or transient cannot and will not be serialized. On the other hand, the readObject()method is used to retrieve (restore) the state of an object from anjava.io.ObjectInputStream.

Serializing an object

Objects are serialized by writing them to an object stream, for example:

// Serialize today's date to a file stream.

FileOutputStream outfile = new FileOutputStream("mytmpfile");

ObjectOutputStream out = new ObjectOutputStream(outfile);out.writeObject(new Date()); // serialize a Date object

out.flush(); // or out.close();

The signature for the constructor is:

ObjectOutputStream(OutputStreamout);

Thus, out can be any object created from any subclass of the java.io.OutputStream class; inthe case, a FileOutputStream object. The writeObject() method is then invoked to store the

state of the object. Many objects can be saved to the same ObjectOutputStream. The sequence

in which the objects are saved will be followed by the

java.io.ObjectInputStream.readObject() method for de-serialization. The signature for the

writeObject() method is:

void writeObject(Object obj);The java.io.ObjectOutputStream class provides a rich set of methods, such as writeInt(),

writeDouble(),.... for object serialization. However, the writeObject() is probably the most

commonly used method.

De-serializing an object

To reverse the process, the following is a typical temple.


24/86


// Deserialize a date from a file stream.

FileInputStream infile = new FileInputStream("mytmpfile");

ObjectInputStream in = new ObjectInputStream(infile);

Date date = (Date) in.readObject();

Ajava.io.ObjectInputStream, in this a FileInputStream, is needed as the source stream for anobject de-serialization. The state of an object is read/retored from the stream. Generally, objectsare read with the readObject() method. Objects will be de-serialized in the sequence they were

serialized. Of course, thejava.io.ObjectInputStream class also provides other de-serialization

methods, such as readInt(), readChar(),...... To demonstrate the serialization and de-

serialization of objects, let us develop a class, named EmpRec, to represent employee records,and then develop two programs to serialize some EmpRec objects and de-serialize the serialized

EmpRec objects. A file stream is used for storing the attributes of these EmpRec objects.

EmpRec.java

// EmpRec class represents the employee information.

// EmpRec is a serializable class./* A class should provide a set of methods: constructor, readers, and writers.

Usually, a pair of reader and writer methods is provided for each attribute.The toString() method defined in Object class is a typical reader method. */

import java.io.*;

public class EmpRec implements Serializable { // attributes

int ID; // employee IDString name; // employee name

public EmpRec(int v, String s) // constructor {

setID(v);setName(s); }

// reader and writer methodspublic String toString() // reader method defined in root class{ return name + ID; } // toString -- defined in Object class

public void setID(int v) { ID = v; }

public int getID() { return ID; }

public void setName(String s) { name = s; }public String getName() { return name; }

} // EmpRec

The expression implement serializable makes all objects created from the EmpRec class and

its subclasses to be serializable. The next program, SaveEmp.java, is to create some EmpRec

objects and serialize them into a file. SaveEmp.java


25/86


// Serializing EmpRec objects into a file stream emp.out.

// This program writes/serializes two EmpRec objects to an ObjectOutputStream.import java.io.*;

public class SaveEmp {

public static void main(String[] args) {

EmpRec emp1 = new EmpRec(99, "Lynda");EmpRec emp2 = new EmpRec(88, "Ava");

try {// Create an ObjectOutputStream object for serialization..

ObjectOutputStream out =new ObjectOutputStream(new FileOutputStream("emp.out"));

// Write the objects to the file "emp.out" out.writeObject(emp1);

out.writeObject(emp2);

out.close();} // try catch (Exception e) { e.printStackTrace(); System.exit(1); }

} // main} // SaveEmp

When executed, the above program, SaveEMp.java, writes two EmpRec objects into the fileemp.out located under the current directory. The MS/DOS command type emp.out or the

UNIX command cat emp.out can be used to verify that the objects are serialized. The file

emp.out is considered to contain binary data. The following program, ReadEmp.java, de-

serialize the EmpRec objects serialized by the previous program, SaveEmp.java.

ReadEmp.java

// De-serializes the EmpRec objects serialized by SaveEmp.java.

// This program de-serializes two EmpRec objects from an ObjectInputStream.import java.io.*;public class ReadEmp {

public static void main(String[] args) {

EmpRec x;

try {// Create an ObjectInputStream for object de-serialization.

ObjectInputStream in =

new ObjectInputStream(new FileInputStream("emp.out"));// Read and deserialize the objects from the file "emp.out"

x = (EmpRec) in.readObject();

System.out.println(x.toString());x = (EmpRec) in.readObject();

System.out.println(x.toString());

in.close(); } // trycatch (Exception e) { e.printStackTrace(); System.exit(1); }

} // main

} // ReadEmp


26/86


To test the above two programs, SaveEmo and ReadEmp, let us develop a standalone application

which invokes SaveEmp.main() and ReadEmp.main() to first save a couple of EmpRec objects

and later retrieve them.

EmpDriver.java

// A driver class used to test ReadEmp and SaveEmppublic class EmpDriver{public static void main(String[] args)

{

String [] x = new String[2];

System.out.println(Saving....); SaveEmp.main(x);System.out.println(Reading....);

ReadEmp.main(x);} // main

} // EmpDriver

C:\>javac EmpDriver.javaC:\>java EmpDriver

Saving....

Reading....

Lynda99

Ava88

Using the JAR commandIn software development, an archive file is generally known as a file which consists of acollection of compiled codes (bytes codes in Java). Thejar command is used to manipulate Java

archive files. Shown below are: (1) creating a jar file, (2) extracting from a jar file, and (3) using

a jar file. In order to use a jar file, it is necessary to update the CLASSPATH variable to include

the jar file path/name.

(1) Create a jar file, named fileA.jar, to contain three bytecodes: SaveEmp, ReadEmp, andEmpRec:C:\>jar cvf fileA.jar SaveEmp.class ReadEmp.class EmpRec.classadded manifest

adding: SaveEmp.class(in = 786) (out= 498)(deflated 36%)adding: ReadEmp.class(in = 857) (out= 512)(deflated 40%)

adding: EmpRec.class(in = 878) (out= 472)(deflated 46%)


27/86


(2) Extracting from the jar file generated from the above step:

C:\> mkdir temp

C:\> cd tempC:\>jar xvf ..\fileA.jarcreated: META-INF/

extracted: META-INF/MANIFEST.MFextracted: SaveEmp.class

extracted: ReadEmp.class

extracted: EmpRec.class

As an example, this step is done in a different directory from the original directory.

(3) Using a jar file does not require the jar file contents to be extracted. However, the

CLASSPATH must be either updated or specified to include a jar file for the programcompilation and execution.

C:\> cp ..\EmpDriver.java

C:\> rm *..class javac -classpath .;..\fileA.jar EmpDriver.javaC:\>java EmpDriverSaving....

Exception in thread "main" java.lang.NoClassDefFoundError: SaveEmpat EmpDriver.main(EmpDriver.java:8)

C:\>java -classpath .;..\fileA.jar EmpDriverSaving...

Reading..

Lynda99

Ava88

Notice that the CLASSPATH option is used in both compiling and running the above program.

To list the options of the jar command:

C:\>jar

Usage: jar {ctxu}[vfm0M] [jar-file] [manifest-file] [-C dir] files ...Options:

-c create new archive

-t list table of contents for archive

-x extract named (or all) files from archive


28/86


-u update existing archive

-v generate verbose output on standard output

-f specify archive file name-m include manifest information from specified manifest file

-0 store only; use no ZIP compression

-M Do not create a manifest file for the entries-C change to the specified directory and include the following file

The jar command is also useful in creating a jar file for running a java program. To do so, amanifest file needs to be created to specify the name of the main class (driver class). The general

steps are:

Compile all java files into bytecodes

C:\>java *.java

Create a manifest file using a text editor, for example,

mytest.txt

Main-Class: EmpDriver

C:\> jar cmf mytest.txt mytest.jar *.class

C:\> java -jar mytest.jar

Saving....

Reading....

Lynda99Ava88

About GUI ApplicationsAll components of a GUI application in Java are derived from the class Component. A GUI

application consists of two major parts: (1) User interface objects and (2) Graphics

context/drawing. Thus, a GUI application must have a container to hold the user interfaceobjects and graphics context. Via the user interface objects user events can be created. The

typical examples of user events are the mouse click and the keyboard activity. An applet is a

client-side Java program which must run inside a web browser. The web browser, therefore,provides the necessary capabilities to manage the browsers window. An applet is simply to

replace the document part of a web page. An applet itself is a container; however, it does not

provide the capability to manipulate the window (web browser) that contains it. Hence, a GUIapplication must have a window-kind of container. But, a GUI application may have many

containers. There are two major kinds of containers: window-kind and non-window-kind.

Windows can further be divided into modal window (dialog window) and modeless window.


29/86


Java AppletListed below is a Java Applet which must be brought up by an Internet browser and thus must be

referenced to by an HTML page using and HTML tags. In otherwords, a Java applet is, in fact, a client application used in an Internet environment to provide

dynamic features that are missing from HTML pages. An applet is known as a client-side Java

application.

// First2.java

// An applet which display Hello, Welcome! at the specified (x, y) position.import java.awt.Graphics;

import javax.swing.JApplet;

public class First2 extends JApplet {public void paint(Graphics x) {

x.drawString("Hello! Welcome!", 20, 25);

} // paint

} // First2

RunFirst2.htm

A Java applet is a class derived from the Applet or JApplet library class. An Internetbrowser expects certain properties (attributes and methods) from a Java applet; such properties

should be transparent to the programmers and should have already been defined in a library

class, such as Applet or JApplet. The Java programmer only needs to extend the libraryapplet to create a new applet to address the solution for the current task. This operation is termed

as inheritance. In other words, a new applet inherits from the library applet class. Theinheritance syntax is:

public class ClassName extends Applet {....}

The Applet or JApplet class is referred to as a super class, a parent class, or a base class.

The new class represented by ClassName is known as the derived class, sub class, or childclass. In the above example program, the class name is First2. The program should be saved

in a file with the same name as the class. The statement import is used to indicate to the Java

compiler that other classes from other packages will be used. Java library classes are saved intomany library packages. For example, the JApplet class is saved in the package javax.swing.

Thus, one of the following statements is used:

import javax.swing.*;import javax.swing.JApplet;

In Java, a simple statement is terminated by a semicolon. A pair of braces is used to construct a

compound statement; thus, the closing brace terminates a compound statement. The aboveprogram also uses the Graphics class of the java.awt package. The term awt stands for

Abstract Windows Tools -- Javas GUI-based application programming interface. A Java

applet is supposed to be presented by the Internet Browser as part of a HTML document and


30/86


thus requires a corresponding HTML file to execute it. Most of the Java development tools will

automatically generate an HTML file for such a purpose. Unlike the Java language, HTML is a

case insensitive programming language. Each statement/directive is enclosed in a pair of anglebrackets and is termed as a tag. The tag indicates the name of the Java class

( bytecode). The width and height indicate the size of the applet. Thus, the above applet is

of size 300 pixels by 80 pixels.

Assuming both First2.java and runfirst2.htm files are saved under the same directory, the

following steps compile and run the above Java applet.

System Prompt>javac First2.java appletviewer runfirst2.htm


31/86


An applet must have either java.applet.Applet or javax.swing.JApplet as its parent class.

A standalone application must contain a method with the following signature:public static void main(String []x)

In general, a GUI-based application must have a window container serving as the user interfaceand a container to hold/glue user interface objects. Hence, there are two major kinds of

containers: window-enabled and non-window. A window container cannot be contained inside

another container; whereas, a non-window container MUST be contained inside another

container. The java.applet.Applet and javax.swing.JApplet classes are non-window containerclasses and signify that they should be executed in an internet browsers environment/window.

A standalone application, on the other hand, needs a window container. The java.awt.Frame or

javax.swing.JFrame is generally used as a window container for a standalone GUI application.

A GUI program may have many containers. A container can consist of user interfacecomponents and graphic context. Only components can react to user events. Graphic context is

simply the drawing on a container and is NOT an object.

It is possible to develop a Java program which can run as a standalone application under a local

operating system and as an applet via a web browser. In other words, there is no need to developtwo versions of the same programs. The mechanism is to provide the necessary and desired

applet methods, such as init() and paint(), as well as the main() method as required by a

standalone application in the same class declaration. The main() method creates an instance of

the class, adds it to its frame container, and invoke the start() method of the applet object. If theprogram is executed as an applet, the main() method is never invoked at all. The next two

program examples illustrate how to implement a Java program to run as an applet as well as a

standalone application.

TwoFace.java


32/86


// Java program to run as an applet and an application

import java.awt.*;import java.applet.Applet;

public class TwoFace extends Applet

{ String msg = "I am an applet and surfing....";

public void paint(Graphics g)

{ g.drawString(msg, 60, 20); } // paint

// The main() method is invoked, when the program runs as an application.// This method is invoked, when the program runs as an application.


{Frame frame1 = new Frame("Application");

TwoFace x = new TwoFace(); // create an applet objectx.msg = "I am an application and running.....";

// Add the applet to the frame

frame1.add(x);

x.start(); // start s the applet object

frame1.setVisible(true); // show the frame object

} // main

} //TwoFace

To run the above program as a standalone application, enter:java TwoFace

To run it as an applet, an HTML file will be needed.

Run.htm

To test the above program as an applet, bring up a web browser and then open up Run.htm fromthe browser. You need to make sure that both TwoFace.class and Run.htm files are located in

the same folder.

Event Listener Interfaces and Methods


33/86


Summarized in the following table are the major event interfaces, their listener methods and

registration (add) methods.

Interface Listener Method Add Method

ActionListener actionPerformed (ActionEvent) addActionListener (ActionListener)

AdjustmentListener adjustValue (ComponentEvent) addAdjustmentListener(AdjustmentListener)

ComponentListener componentHidden(ComponentEvent)componentMoved(ComponentEvent)

componentResized(ComponentEvent)

componentShown(ComponentEvent)

addComponentListener(ComponentListener)

ContainerListener componentAdded(ContainerEvent)

componentRemoved(ContainerEvent)

addContainerListener

(ContainerListener)

FocusListener focusGained(FocusEvent)

focusLost(FocusEvent)

addFocusListener

(FocusListener)ItemListener itemChanged(ItemEvent) addItemListener

(ItemListener)

KeyListener keyPressed(KeyEvent)

keyReleased(KeyEvent)

keyTyped(KeyEvent)

addkeyListener

(KeyListener)

MouseListener mouseClicked(MouseEvent)

mouseEntered(MouseEvent)

mouseExited(MouseEvent)mousePressed(MouseEvent)

mouseReleased(MouseEvent)

addMouseListener

(MouseListener)

MouseMotionListener

mouseDragged(MouseEvent)mouseMoved(MouseEvent)

addMouseMotionListener(MouseMotionListener)

TextListener textValueChanged(TextEvent) addTextListener

(TextListener)

WindowListener windowActivated(WindowEvent)

windowClosed(WindowEvent)

windowClosing(WindowEvent)

windowDeactivated(WindowEvent)windowDeiconified(WindowEvent)

windowIconified(WindowEvent)

windowopened(WindowEvent)

addWindowListener

(WindowListener)

Associated with each of the above interfaces, there is a method used to de-register an object fromthe interface. The naming convention for this method is:

removeInterFaceName(.)

For example,removeActionListener (ActionListener)

// DrawLine4.javaimport java.awt.*;


34/86


import java.applet.Applet;


public class DrawLine4 extends Applet implements MouseListener, MouseMotionListener{

final int MAXLINES = 10;Point starts[] = new Point[MAXLINES]; // starting points

Point ends[] = new Point[MAXLINES]; // ending points

Point anchor; // start of current linePoint currentpoint; // current end of line

int currline = 0; // number of lines

public void init(){ // register event listeners

addMouseListener(this);

addMouseMotionListener(this);

} // init

// MouseListener listener methodspublic void mouseClicked(MouseEvent e) {}

public void mouseEntered(MouseEvent e) {}

public void mouseExited(MouseEvent e) {}public void mousePressed(MouseEvent e) // same as mouseDown in JDK 1.0

{ anchor = new Point(e.getX(),e.getY()); }

public void mouseReleased(MouseEvent e) // same as mouseUp in JDK 1.0

{ addline(e.getX(),e.getY()); }

// MouseMotionListener listener methods

public void mouseDragged(MouseEvent e) // same as mouseDrag in JDK 1.0{

currentpoint = new Point(e.getX(),e.getY());

repaint();}

public void mouseMoved(MouseEvent e) {}

void addline(int x,int y){

starts[currline] = anchor;

ends[currline] = new Point(x,y);++currline;

currentpoint = null;

anchor = null;repaint();

} // addline

public void paint(Graphics g)


35/86


{

// Draw existing lines

for (int i = 0; i < currline; i++)g.drawLine(starts[i].x, starts[i].y, ends[i].x, ends[i].y);

// draw current line

g.setColor(Color.yellow);if (currentpoint != null)

g.drawLine(anchor.x,anchor.y,

currentpoint.x,currentpoint.y);}

}

Let us use the MouseListener interface as the event listener to capture the mouse click. In this

program, a click on the mouse causes a blue square be displayed at the mouse clicking point.

//DrawDot3.java

// Display a filled square at the mouse pointer when the mouse is pressed.// Using a frame as the container, instead of an applet.


import java.awt.*;

public class DrawDot3 extends Frame implements MouseListener, WindowListener{

private int x, y = 0; // x, y coordinatespublic DrawDot3() // Default constructor

{

setTitle("DrawDot3");// Register to the event listeners

addMouseListener(this);addWindowListener(this);

} // constructor

public static void main(String[] args)

{ DrawDot3 x = new DrawDot3();

x.setSize(250, 250);

x.setVisible(true);

}

// Draw a blue square at the point (x, y)public void paint(Graphics g)

{

g.drawString("("+x+", "+y+")", x-5, y-5);

g.setColor(Color.blue);


36/86


g.fillRect(x, y, 7, 7);

} // paint

// MouseListener listener methods

// When the mouse is pressed, the mouse pointer location will be stored in (x, y)

public void mousePressed(MouseEvent e){

// Get (x, y) coordinates using getX() and getY() methods

x = e.getX();y = e.getY();

repaint();

}

public void mouseClicked(MouseEvent e) {}

public void mouseEntered(MouseEvent e) {}

public void mouseExited(MouseEvent e) {}

public void mouseReleased(MouseEvent e) {}

// Listener methods declared in the WindowListener interface

public void windowClosing(WindowEvent e)

{setVisible(false); // or dispose();

System.exit(1);

} // windowClosing

public void windowClosed(WindowEvent e) { }

public void windowDeiconified(WindowEvent e) { }

public void windowIconified(WindowEvent e) { }public void windowActivated(WindowEvent e) { }

public void windowDeactivated(WindowEvent e) { }

public void windowOpened(WindowEvent e) { }

} // DrawDot3


37/86


Using MenusThe steps of adding the menu capability are:1. create a menu bar

2. activate the menu bar

3. create a menu

4. add the menu to the menu bar 5. create a menu item

6. add the menu item to the menu

The javax.swing package provides classes to support the memnu capability. These class are:

JMenuBar, JMenu, and JMenuItem. The method setMenuBar() allows javax.swing.JFrame to set

an active menu bar. One menu bar can be set to active at any given point of time. In order toreact to the click on a menu item event, the ActionListener interface will be used. Hence, a

menu item works almost identically to a push button (javax.swing.JButton). Each menu and

menu item is associated with a label. Separators can also be added by calling the method

addSeparator() of the JMenu class. The Java statements corresponding to the steps listed above

may look like:1. JMenuBar menuBar = new JMenuBar();

2. setMenuBar(menuBar); // e.g., new JFrame().setMenuBar(menuBar);3. JMenu menuA = new JMenu(A Menu);

4. menuBar.add(menuA);

5. JMenuItem menuItemA = new JMenuItem(Menu Item A);6. menuA.add(menuItemA);

The following program example, UseMenu.java, shows how menu capabilities can beimplemented in a GUI program. This program also demonstrates how to implement an event

withdrawal and to activate a specific menu bar.

// Using JMenuBar, JMenu, and JMenuItem to set up menusimport javax.swing.*;


public class UseMenu extends JFrame implements ActionListener

{

JMenuItem item1, item2, item3, item4, item5, item6;JMenuBar menuBar1, menuBar2;


{UseMenu x = new UseMenu();

x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

x.setSize(350, 250);x.setVisible(true);

} // main

// constructor


38/86


public UseMenu()

{

setTitle("Using Menus");// Step 1 create menu bar

menuBar1 = new JMenuBar();

menuBar2 = new JMenuBar();// Step 2 activate a menu bar

setJMenuBar(menuBar1);

// Step 3 create menuJMenu menuA = new JMenu("Menu 1");

JMenu menuB = new JMenu("Menu 2");

JMenu menuC = new JMenu("Menu 3");

// Step 4 add menu to a menu barmenuBar1.add(menuA);

menuBar1.add(menuB);

menuBar2.add(menuC);

// Step 5 create menu itemitem1 = new JMenuItem("ONE");

item2 = new JMenuItem("2");item3 = new JMenuItem("Switch menu bar");

item4 = new JMenuItem("Selection #4");

item5 = new JMenuItem("change size");item6 = new JMenuItem("Exit");

// Step 6 add menu item to a menu

menuA.add(item1);

menuA.addSeparator();menuA.add(item2);

menuB.add(item3);

menuB.addSeparator();menuB.add(item4);

menuB.add(item5);

menuC.add(item6);// event registrationitem1.addActionListener(this);

item2.addActionListener(this);

item3.addActionListener(this);item4.addActionListener(this);

item5.addActionListener(this);

item6.addActionListener(this);} // constructor

public void actionPerformed(ActionEvent e){

if (e.getSource() == item1)

setTitle("Menu Item1 selected");



39/86


{

setTitle("Welcome to Menu Item2");

item2.removeActionListener(this);}


{setTitle("New menu bar");

setJMenuBar(menuBar2);

}if (e.getSource() == item4)

setTitle("4 is a simple Four");


{setTitle("Give me 5");

setSize(190, 210);

}

if (e.getSource() == item6)System.exit(0);

repaint();

} // actionPerformed

} // UseMenu


40/86


Advanced Swing FeaturesThe javax.swing package provides many classes to support the development of GUI applications.Classes covered here include JList, JTree, JTable, JEditorPane, JSplitPane, JTabbedPane,

JDesktopPane, and JInternalFrame.

javax.swing.JList classConstructors:

JList();

JList(ListModel x);JLIst(Object [] x);

JList(Vector x);

Methods used in UseJList1.java:

int getSelectedIndex(); // returns the index of the selected item

int [] getSelectedIndices(); // returns the indices of the selected items

Object getSelectedValue(); // returns the selected item as an Object

Object [] getSelectedValues(); // returns the selected items as an Object arrayvoid set SelectionMode(int m); // sets the mode to be single or multiple selection

//UseJList1.java

// Using javax.JList to allow a single selection at a time

import java.awt.*;import java.awt.event.*;

import javax.swing.*;

import javax.swing.event.*;public class UseJList1 extends JFrame

{

JLabel label;JList myList;String [] msg = {"BMW","Vacation","Free lunch","Try again","Try harder"};


{UseJList1 x = new UseJList1();



} // main

public UseJList1() // constructor{

setTitle("UseJList1");

String [] s = new String[5];for (int k=0; k < s.length; ++k)

s[k] = "Try Me" + k;

myList = new JList(s); // create a JList object from a String array// Allow only single selection


41/86


myList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

JScrollPane sp = new JScrollPane(myList); // adding scrolling capability

JPanel p = new JPanel();p.add(sp);

// Event registration and handling

// The ListSelectionListener interface handles a click on a list item. myList.addListSelectionListener(new ListSelectionListener(){

public void valueChanged(ListSelectionEvent e){

String value = (String) myList.getSelectedValue();

label.setText(value + " says: " + msg[myList.getSelectedIndex()]);

}});

getContentPane().add(p, BorderLayout.SOUTH);

label = new JLabel("Try Your Luck");

getContentPane().add(label, BorderLayout.NORTH);} // constructor

} // UseJList1

// FileList.java

// Using javax.Jlist to show the current directory contentsimport java.io.*;

import java.awt.*;


import javax.swing.*;import javax.swing.event.*;

public class FileList extends JFrame {

JLabel label;JList myList;

JTextField fileType;

String []dirList;public static void main(String []args) {

FileList x = new FileList();



} // main

public FileList(){// constructorsetTitle("FileList");

try { File mypath = new File("."); // current directory

dirList = mypath.list(); // get the file list} catch(Exception e) { e.printStackTrace(); System.exit(2); }

JPanel p = new JPanel();

fileType = new JTextField(20);

p.add(fileType);


42/86


myList = new JList(dirList); // create a JList object


JScrollPane sp = new JScrollPane(myList); // adding scrolling capabilityp.add(sp);


label = new JLabel("");getContentPane().add(label, BorderLayout.NORTH);

// event registration and handling

// The ListSelectionListener interface handles a click on a list item.myList.addListSelectionListener(new ListSelectionListener() { public void

valueChanged(ListSelectionEvent e) { String v = (String) myList.getSelectedValue();

label.setText(v);

if ((new File(v)).isFile()) fileType.setText(v + " is a file");if ((new File(v)).isDirectory()) fileType.setText(v + " is a directory");

} });

} // constructor

} // FileList

The next program retrieves database records and displays them in a JList.

// UseJList2.java// Using javax.JList to display database records

import java.awt.*;



import java.sql.*;

import java.util.*;

public class UseJList2 extends JFrame

{JLabel label;

JList myList;

Vector lName; // store last names

Object []fName; // hold first namespublic static void main(String []args)

{

UseJList2 x = new UseJList2();x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);


x.setVisible(true);} // main

public UseJList2() // constructor

{


43/86


setTitle("UseJList2");

lName = new Vector(); // store last names

try { getRecord(); // Retrieve database records

} catch(Exception e) { System.err.println(e); }

myList = new JList(lName); // create a JList object based on last names// Allow only single selection


JScrollPane sp = new JScrollPane(myList); // adding scrolling capabilityJPanel p = new JPanel();

p.add(sp);

// event registration and handling

// The ListSelectionListener interface handles a click on a list item.

myList.addListSelectionListener (new ListSelectionListener()

{

public void valueChanged(ListSelectionEvent e)

{label.setText(fName[myList.getSelectedIndex()].toString());

}});


label = new JLabel(); // used to show the first namegetContentPane().add(label, BorderLayout.NORTH);

} // constructor

public void getRecord() throws Exception

{

// The name of the JDBC driverString driverName = "sun.jdbc.odbc.JdbcOdbcDriver";

// JDBC connection URL

String connectionURL = "jdbc:odbc:SimpleDB";Connection con = null; // JDBC Connection object

Statement stmt = null; // JDBC Statement object

// SQL statement used to retrieve records

String sqlStatement = "SELECT LastName, FirstName FROM PEOPLE";ResultSet rs = null; // JDBC ResultSet object

try

{Class.forName(driverName).newInstance(); // Load the driver

// Establish a database connection

con = DriverManager.getConnection(connectionURL);stmt = con.createStatement(); // Create the SQL statement

rs = stmt.executeQuery(sqlStatement); // Execute the query

Vector v = new Vector();

// Step through the entire ResultSet


44/86


while (rs.next())

{

lName.addElement(rs.getString(1)); // get the last name v.addElement(rs.getString(2)); // get the first name

} // while

fName = v.toArray(); // convert the first names into an array} // try

catch (Exception e) { System.err.println(e); }

finally{ // Cleaning up

if (rs != null) rs.close();

if (stmt != null) stmt.close();

if (con != null) con.close();} // finally

} // getRecord

} // UseJList2

javax.swing.JTree class

Constructors:JTree();

JTree(Hashtable x); // create a tree object based on a Hashtable

JTree(TreeNode x); // create a tree object based on a TreeNode

JTree(TreeNode x, boolean leaf); // true, if child node is a leaf nodeJTree(TreeModel x); // create a tree object based on a TreeModel

JTree(Object []x); // create a tree object based on an Object arrayJTree(Vector x); // create a tree object based on a Vector

// UseJTree1.java

// Using javax.JTree to create and show a list of stringsimport java.awt.*;



public class UseJTree1 extends JFrame

{

JTree myTree;public static void main(String []args)

{

UseJTree1 x = new UseJTree1();x.setSize(180, 200);

x.setVisible(true);

x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);} // main


45/86


public UseJTree1() // constructor

{setTitle("UseJTree1");

String []s = new String[10];

for (int k=0; k < s.length; ++k) s[k] = "Hello " + k;myTree = new JTree(s); // create a JTree object based on a String array

JScrollPane sp = new JScrollPane(myTree); // adding scrolling capability

getContentPane().add(sp);} // constructor

} // UseJTree1

The above program simply creates a JTree object to show a list of strings. No event associated

statements were added. Each node in the tree is a leaf node and does not any child nodes. Thus,

the icons shown in the above figure are leaf icons. The DefaultMutableTreeNode class

represents a node in a tree component and is one of many tree node related classes facilitated bythejavax.swing.tree package. Thus, a tree node can be created by call the constructor:

DefaultMutableTreeNode(Object x);

// UseJTree2.javaimport java.awt.event.*;


import javax.swing.tree.*;

import javax.swing.event.*;public class UseJTree2 extends JFrame {

JTree myTree;


UseJTree2 x = new UseJTree2();



} // main


{

setTitle("UseJTree2");String []s = {"Hello", "Howdy", "Hey", "Hi"};

DefaultMutableTreeNode temp;

DefaultMutableTreeNode myRoot = new DefaultMutableTreeNode("Top");for (int k=0; k < s.length; ++k)

{

temp = new DefaultMutableTreeNode(s[k]);

// add 4 child nodes


46/86


for (int n=1; n


47/86


DefaultMutableTreeNode myRoot = new DefaultMutableTreeNode("Top");

for (int k=0; k < s.length; ++k)

{temp = new DefaultMutableTreeNode(s[k]);


for (int n=1; n


48/86


DefaultMutableTreeNode myRoot;

DefaultTreeModel treeMod; // a tree model

public static void main(String []args) {UseJTree4 x = new UseJTree4();



} // main


{

setTitle("UseJTree4");

String []s = {"Hello", "Howdy", "Hey", "Hi"};DefaultMutableTreeNode temp;

myRoot = new DefaultMutableTreeNode("Top");



for (int n=1; n


49/86


public void actionPerformed(ActionEvent e)

{ // 1. Asking the tree which node was selected

DefaultMutableTreeNode selectedNode =

(DefaultMutableTreeNode) myTree.getLastSelectedPathComponent();

if (selectedNode == null) return; // no node was selected

// 2. Asking the selected node who is its parentDefaultMutableTreeNode parent =

(DefaultMutableTreeNode) selectedNode.getParent();

if (parent == null)return; // There can be only one rootnode

// create a new tree node

DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("New");

// 3. Asking the parent node for the index of the selected node

int selectedIndex = parent.getIndex(selectedNode);

// 4. Adding the new node to the tree model at the same level

treeMod.insertNodeInto(newNode, parent, selectedIndex + 1);

// 5. Builds an array of nodes for a specific node and upTreeNode[] nodes = treeMod.getPathToRoot(newNode);

TreePath path = new TreePath(nodes); // create a new tree path// 6. Redisplays the tree nodes to show the newly added node

myTree.scrollPathToVisible(path);

}});

childlevel.addActionListener (new ActionListener()

{

public void actionPerformed(ActionEvent e){ // get the selected node



if (selectedNode == null)

return; // no node was selected

// create a new tree node

DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("New");

// 7. Adding the new node to the tree model at the lower leveltreeMod.insertNodeInto(newNode, selectedNode, selectedNode.getChildCount());

TreeNode[] nodes = treeMod.getPathToRoot(newNode);

TreePath path = new TreePath(nodes);

myTree.scrollPathToVisible(path); // display the new node

}});

delete.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e)

{ // get the selected node



50/86



if (selectedNode != null && selectedNode.getParent() != null)

// 8. remove a node from the tree model

treeMod.removeNodeFromParent(selectedNode);

}

});} // addButton} // UseJTree4

Let us take a closer look at the methods and classes used in the preceding example,

UseJTree4.java. In addition to the DefaultTreeModel class, this program also uses the

javax.swing.tree.TreePath class which represents a path to a node in a tree and is used toconstruct a path from an array of tree nodes in order to uniquely identifying the path from the

root of the tree to a specific node. The following constructor is used to instantiate an object from

the DefaultTreeModel class:

DefaultTreeModel(TreeNode x); // Creates a tree in which any node can have child nodes

// where x represents the root for a set of tree nodesOther methods used in UseJTree4.java include:

1. Object getLastSelectedPathComponent(); // JTree classReturns the selected node

2. TreeNode getParent(); // DefaultMutableTreeNode class

3. int getIndex(TreeNode ChildNode); // DefaultMutableTreeNode class

Returns the index of the specified child node.

4. void insertNodeInto(TreeNode x, TreeNode parent, int where); // DefaultTreeModelclass

Adds the newnode x as a child node of parent node at the index where.

5. TreeNode [] getPathtoRoot(TreeNode x); // DefaultTreeModel class

Returns an array of tree nodes from the immediate parent of a specific node up to and

including the root node. The last element in the returned array is the node.

6. void scrollPathToVisible(TreePath path); // JTree class

Displays tree nodes. The JTree object must be contained in a JScrollPane container.

7. int getChildCount(); // DefaultMutableTreeNode class

Returns the number of children of the node.

8. void removeNodeFromParent(MutableTreeNode x); // DefaultTreeModel class

Removes a child node from the current node

Tree TraversalThejavax.swing.tree.DefaultMutableTreeNode class provides four tree traversal methods:

Enumeration breadthFirstEnumeration();


51/86


Enumeration depthFirstEnumeration();

Enumeration preorderFirstEnumeration(); // same as depthFirst

Enumeration postorderFirstEnumeration(); // reverse of preorder

// UseJTree5.java

// Visiting tree nodes in two different ways: breadth first and depth first.import java.awt.*;


import javax.swing.*;import javax.swing.tree.*;

import javax.swing.event.*;

import java.util.*;public class UseJTree5 extends JFrame {

JTree myTree;


DefaultTreeModel treeMod;

JScrollPane sp2;public static void main(String []args) {

UseJTree5 x = new UseJTree5();x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);


x.setVisible(true);} // main


{setTitle("UseJTree5");

String []s = {"Hello", "Howdy", "Hey", "Hi"};DefaultMutableTreeNode temp;myRoot = new DefaultMutableTreeNode("Top");

for (int k=0; k < s.length; ++k) {

temp = new DefaultMutableTreeNode(s[k]);for (int n=1; n


52/86


x = (DefaultMutableTreeNode) nodeRec.nextElement();

v.addElement(x.toString());

}JList nodeList = new JList(v);

getContentPane().add(new JScrollPane(nodeList));

v = new Vector();

nodeRec = myRoot.depthFirstEnumeration(); // depth firstwhile (nodeRec.hasMoreElements()) {

x = (DefaultMutableTreeNode) nodeRec.nextElement();

v.addElement(x.toString());

}

nodeList = new JList(v);getContentPane().add(new JScrollPane(nodeList));

} // constructor

} // UseJTree5

The next program demonstrates how to visit tree nodes in the original order in which they are

added to the tree. A recursive function is used to visit each node at all levels of a tree.

// UseJTree6.java// Showing the sub-tree of a selected node

import java.awt.*;import java.awt.event.*;


import javax.swing.tree.*;import javax.swing.event.*;

import java.io.*;

import java.util.*;

public class UseJTree6 extends JFrame

{

JTree myTree;DefaultMutableTreeNode myRoot;

DefaultTreeModel treeMod;

JTextArea outbox;


{UseJTree6 x = new UseJTree6();



x.setVisible(true);


53/86


} // main

public UseJTree6() // constructor{


String []s = {"Hello", "Howdy", "Hey", "Hi"};DefaultMutableTreeNode temp;

myRoot = new DefaultMutableTreeNode("Top");

for (int k=0; k < s.length; ++k) {temp = new DefaultMutableTreeNode(s[k]);

for (int n=1; n


54/86


});

} // addButton

// print each tree node recursively

void printNode(DefaultMutableTreeNode node)

{int k = node.getChildCount(); // Get child count

if (k == 0) // This is a leaf node; recursion stops here

{outbox.setText(outbox.getText() + node.toString() + "\n"); // print the leaf

return;

}

// print a root node and the number of child nodes it has outbox.setText(outbox.getText() + node.toString() + " " + k + "\n");

// Asking each child node to print itself

for (int n=0; n < k; ++n)

printNode((DefaultMutableTreeNode) node.getChildAt(n)); // recursive call} // printNode

} // UseJTree6

// UseJTree7.java

// Adding, removing, showing, and saving tree nodesimport java.awt.*;


import javax.swing.*;import javax.swing.tree.*;import javax.swing.event.*;

import java.io.*;

public class UseJTree7 extends JFrame {JTree myTree;


DefaultTreeModel treeMod;JTextArea outbox;

PrintWriter outfile;

public static void main(String []args) {UseJTree7 x = new UseJTree7();



} // main

public UseJTree7() // constructor{


55/86



String []s = {"Hello", "Howdy", "Hey", "Hi"};

DefaultMutableTreeNode temp;myRoot = new DefaultMutableTreeNode("Top");




for (int n=1; n


56/86


DefaultMutableTreeNode parent =

(DefaultMutableTreeNode) selectedNode.getParent();

if (parent == null) return;DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("New");

int selectedIndex = parent.getIndex(selectedNode);

// adding the new node to the top level nodetreeMod.insertNodeInto(newNode, parent, selectedIndex + 1);

// display the new node

TreeNode[] nodes = treeMod.getPathToRoot(newNode);TreePath path = new TreePath(nodes);

myTree.scrollPathToVisible(path);

}

});

childlevel.addActionListener(new ActionListener()

{

public void actionPerformed(ActionEvent e){

DefaultMutableTreeNode selectedNode =(DefaultMutableTreeNode) myTree.getLastSelectedPathComponent();

if (selectedNode == null) return;

DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("New");// add the new node

treeMod.insertNodeInto(newNode, selectedNode, selectedNode.getChildCount());

// display the new node

TreeNode[] nodes = treeMod.getPathToRoot(newNode);TreePath path = new TreePath(nodes);

myTree.scrollPathToVisible(pa

exception handling.doc

Documents