CIS 121 March 27, 2000

Review for Exam 2

You will need to recall some of the major ideas we have dealt with earlier this semester. For example, the class header has the form

<access control keyword> class classname <extends A> <implements B,C,etc...>

where A represents the parent class and B,C,etc... represent interfaces. When we use the extends class we say that the current class is a subclass of the class which we extend.

Remember that Java only support single inheritance, but we can implement as many interfaces as we want.

In order for a Java application to run, it must have a main method.

An exception is a event which occurs that makes program execution either impossible or undesirable.

Java implements a termination model for exception handling. This means that when an exception is thrown (and is not dealt with in a catch block), the interpreter will terminate execution instead of resuming.

The Throwable class is the ancestor of all exceptions. It has two main subclasses, Error and Exception. The classes that inherit from Error are error which cannot be handled by the user. Such events are running out of memory during execution of a program. These errors cannot be recovered from. The classes that inherit from Exception are those that can usually be recovered, with at least one exception. The RunTimeException class represents errors which cannot be recovered from The IOException class is a descendant of the Exception class and acts as a parent class for various I/O Exceptions.

We may also define our own exceptions.

Java provides a construct for us to use to handle exceptions. This is the try-catch block. The try portion acts as a wrapper for code which might possibly cause an exception to occur. In the catch block(s) we define code to deal with exceptions which may occur when the code in the try block is executed. If an exception is thrown and there is no catch block to deal with it, then Java deals with the exception(s) as it would if there were no try-catch block. An optional block called finally may be added to a try-catch block. The code within finally, if it is defined, is executed whenever the try-catch block is exited even if no exception was thrown in the try block. This allow us to release any system resources we might have used in the try block. This block is similar to the finalize method which can be placed in class definitions.

There are two other keywords that are related to exceptions. One is throw and the other is throws. throws is placed in the header of a method and is followed by the name of an exception to indicate that the code within the method might possibly generate that exception. throw is most commonly placed in the body of a try block and is followed by a call to the constructor of an exception class. It creates a new instance of the exception and throws to the catch blocks if there is one defined to handle the exception.

Recall that methods can be classified as either abstract or concrete. A concrete method is a method which has an implementation. An abstract class has no implementation.

Classes can also be classified as either abstract or concrete. A concrete class is a class in which all its methods are concrete. An abstract class is one is which at least one of its methods is abstract.

If a class is abstract we cannot create objects from it. We can use the keyword abstract in the header of a class to indicate this.

An interface is a Java construct that only contains abstract methods or interface constants.

Examples of interfaces are Cloneable and Serializable.

Cloneable is an interface which contains the method clone(). This allows us to create an identical object with its own space on the heap.

Serializable is an interface which allows us to write out objects to a file.

In order to use an interface we place the keyword implements followed by the name of the interface in the class header. As the name implies we must implement the interface. That is, we must implement each method defined in the interface within our class.
There is a very important and powerful aspect of implementing interfaces. Since an interface is an object it can be used as a parameter type. Any oject that is instantiated from a class that implements an interface is a valid parameter to a method with that interface as a parameter type. For example,

In the method public void createClone(Cloneable c), if we create an object from a class that implements the Cloneable Interface, then we may send that object to createClone.

When we implement an interface we must implement all the methods in the interface. If only one of the methods is important to us, then we must also implement all of the other methods, but we can simply give the ones that aren't important to us null bodies.

Polymorphism allows a given method call to be implemented in different versions.

Graphical User Interfaces

Java provides support for Graphical User Interfaces with the AWT package. AWT is an acronym that means Abstract Windowing Toolkit. It contains all the classes necessary to create and use Graphical User Interfaces.

One of the main classes found in the AWT package is the class Component. Component contains many important methods. Among those are the following.

public void setSize(int width,int height) - used to set the width and height in pixels of the Component
public void setBackground(Color c) - used to set the background color of the Component
public void setVisible(boolean b) - used to make the Component visible or invisible
public void setLocation(int x,int y) - used to set the Location of the upper left-hand corner of the Component
public Graphics getGraphics() - used to create a Graphics object associated with that Component
public void paint(Graphics g) - used to draw Graphics on a Panel or Applet
public void update(Graphics g) - used to clear the drawing area before making a call to paint
public void repaint() - used to make a call to update as soon as the controlling environment (browser/appletviewer) can

One of the subclasses of Component is Container. Within Container there are some important methods that we use when creating Graphical User Interfaces.

public Component add(Component comp) - used to add a Component to a Container
public void setLayout(LayoutManager mgr) - used to set the Layout of the Container

There are several predefined Layout Managers including FlowLayout, GridLayout. A FlowLayout manager places components in rows until a row is filled, then components are placed on the next row. GridLayout allows us to place components within a container in a grid. We may also choose to use no Layout manager. In this case, we use null as a parameter to setLayout.

An important subclass of Container is Window. Within the Window class, there is one important, addWindowListener, the signature of this method is

public void addWindowListener(WindowListener l)
An important subclass of Window is Frame. A Frame has a boundary around it and a Title Bar. An important method within the Frame class is public synchronized void setMenuBar(MenuBar mb)

The Menu and MenuItems are specific to Frames. We cannot place them in containers like Panels.

An important aspect of Java and Graphical User Interfaces is that we can implement event-driven programming. This is characterized by times when your program is "doing nothing" and when the operating system is "listening" for user input.

There are several Components we can place into a Container which can implement event-driven programming.

There are several interfaces which were written to implement event-driven programming.

Interface	Methods
ActionListener	public abstract void actionPerformed(ActionEvent e)
ItemListener	public abstract void itemStateChanged(ItemEvent e)
MouseListener	public abstract void mouseClicked(MouseEvent e) public abstract void mousePressed(MouseEvent e) public abstract void mouseReleased(MouseEvent e) public abstract void mouseEntered(MouseEvent e) public abstract void mouseExited(MouseEvent e)
WindowListener	public abstract void windowActivated(WindowEvent e) public abstract void windowClosed(WindowEvent e) public abstract void windowClosing(WindowEvent e) public abstract void windowDeactivated(WindowEvent e) public abstract void windowDeiconified(WindowEvent e) public abstract void windowIconified(WindowEvent e) public abstract void windowOpened(WindowEvent e)
TextListener	public abstract void textValueChanged(TextEvent e)

There are several Components that can be placed in a Container and cause events to occur. We have discussed in detail the following.

Component	Event Generated
Button	ActionEvent
Checkbox	ItemEvent

There are other Components that can be placed in a Container but these are the two that we have discussed. Recall that we can also create Radio Buttons by using a Checkboxgroup as a parameter to a constructor of the Checkbox class. When Radio Buttons are created only one of them can be selected at a time.

In order for the interpreter to listen for these events to occur there are methods which we must call.

Component	Code added
Button	addActionListener(ActionListener l)
Checkbox	addItemListener(ItemListener l)

When we run an application it runs in its own window. We can use the method addWindowListener to cause the interpreter to listen for Window Events such as closing the Window.

Recall again the importance of Interfaces as parameter types. The object we pass to addActionListener must be an object that is created from a class that implements the ActionListener interface. A common parameter used in a call to addActionListener is this. this is only appropriate if the class we are defining implements the interface ActionListener. There are instances in which this would not be a valid parameter to methods like addActionListener. We will see an example of this when we look at Threads.

In order to deal with events that occur from these Components we need to implement the interface associated with the listener we place on that Component. The two main interface method we have implemented are public void actionPerformed(ActionEvent e) from ActionListener and public void itemStateChanged(ItemEvent e) from ItemListener.

When we handle events there are several methods that are important. When we handle an event occuring from an ActionEvent, we have getActionCommand() and getSource() available. getActionCommand() returns the text associated with the Component that caused the event to occur. getSource() returns an object. When we handle an event occcuring from an ItemEvent, we have getItem() which for our purposes returns the label of the Checkbox which was checked or unchecked.

Recall the sequence of events when we detect and act on button clicks and detect and act on checking or unchecking a checkbox.
Button clicks

We create the Button object button with buttonLabel and add it to a Container.
We tell the interpreter to listen for button clicks by adding the line button.addActionListener(this);.
When the user clicks on the Button an ActionEvent object is created and the method actionPerformed is called.
Within actionPerformed we can either use getSource() or getActionCommand() to determine the button click that caused the event to occur.

Checking or unchecking a checkbox

We create the Checkbox object checkbox with checkboxLabel and add it to a Container.
We tell the interpreter to listen for checking or unchecking by adding the line checkbox.addItemListener(this);.
When the user checks or unchecks checkbox an ItemEvent object is created and the method itemStateChanged is called.
Within itemStateChanged, we use the method getStateChange() to determine whether the box was checked or unchecked. We can use the two static integer variables ItemEvent.SELECTED and ItemEvent.DESELECTED to detect whether or the event that triggered the call to itemStateChanged() was a checkbox being checked or unchecked.
After we have determined whether or not the event was a checkbox being checked or unchecked we can use getItem() to get the label of the checkbox that was checked or unchecked.

We have also used TextFields. We have used two important methods with TextFields, getText() and setText(). Recall that the object in a TextField is a String. If we wish to use this as an integer, double, float, etc., then we must convert the String. We can do this by using the static class method valueOf which is located in the appropriate class. For example, if we wish to convert the String to an int, then we make a call to the static class method valueOf in the Integer class. This will create an Integer object, and then we can use the intValue() method to place the value into an int variable. For example, if we have a TextField component named textField, then to convert the String in that TextField to an int called myInt, then we would use the following code.

myInt = (Integer.valueOf(textField.getText())).intValue();
Recall that the classes ActionEvent, ItemEvent, etc., and the interfaces ActionListener, ItemListener, etc. are found in the java.awt.event package.

Another important class we have discussed is the Applet class. This class is found in the java.applet package. The Applet class is a subclass of Panel which is a subclass of Container.

An applet, unlike an application, cannot run by itself. It must be run in the context of a web browser or appletviewer. In order to run an applet we must create an HTML file containing a tag which will load the applet. HTML is an acronym that means Hypertext Markup Language. It is the language in which web pages are written. HTML contains tags which a web browser can interpret. The following is the HTML code which is needed to load and execute an applet.

width and height are measured in pixels and tell the browser how large the applet is. MyApplet is the name of the class file created from compiling the source code for the applet.

We can send values into an applet from HTML. We do this by using the tag

<param name="myname" value="myvalue">
Within the applet we would call the method getParameter("myname") to retrieve the value myvalue.

There are seven methods which are commonly implemented in Applets even though can implement other methods such as those from Interfaces. These seven methods are

public void paint(Graphics g) - normally used to draw graphics on a Panel or Applet
public void update(Graphics g) - by default will clear the entire drawing area and then call paint
public void repaint() - makes a call to update as soon as the controlling environment (browser/appletviewer) can
public void init() - is executed one time when an applet is loaded
public void start() - is executed each time an applet becomes visible
public void stop() - is executed each time the applet becomes invisible
public void destroy() - is executed one time when the controlling environment (browser/appletviewer) is closed

The first three methods are inherited from the Component class. The last four are inherited from the Applet class.

The Graphics class is an abstract class, and, therefore, a Graphics object cannot be instantiated through a constructor. It must be created through a call to getGraphics(). There are several methods that may be used by Graphics objects.

public abstract void clearRect(int x,int y,int width,int height)
clears a rectangular area whose upper left-hand coordinate is (x,y) with the specified width and height

public abstract void drawLine(int xl,int yl,int x2,int y2)
draws a line from (x1,y1) to (x2,y2)

public abstract void drawOval(int x,int y,int width,int length)
draws an oval whose bounding box is a rectangle whose upper left-hand corner is (x,y) with the specified width and height

public void drawRect(int x,int y,int width,int height)
draws a rectangle whose upper left-hand coordinate is (x,y) with specified width and height

public abstract void drawString(String str,int x,int y)
draws a string on the Panel or Applet at the coordinates (x,y)

public abstract void fillOval(int x,int y,int width,int height)
draws an oval like drawOval does but fills it with the drawing color

public abstract void fillRect(int x,int y,int width,int height)
draws a rectangle like drawRect does but fills it with the drawing color

public void drawPolygon(int xpoints[],int ypoints[],int points)
draws a polygon on the Panel or Applet whose coordinates are specified in the arrays xpoints and ypoints and the number of points in the polygon specified by points

public void fillPolygon(int xpoints[],int ypoints[],int points)
draws a polygon like drawPolygon does but fills it with the drawing color

public abstract void setColor(Color c)
sets the color to use for drawing

Note that the call to drawOval and drawRect are almost the same. The difference is that in the drawOval method, an oval is drawn so that it will touch all four edges of the rectangle specified. This rectangle is called the bounding box. If we use different values for width and length, then the oval will be an ellipse. If we use the same value for the width and lenght, then the oval will be a circle.

Recall that when an applet is loaded the first method that is executed is the constructor if there is one. The next method run is the init method. Then the method start is run since the applet becomes visible. If we place code such as an infinite loop in the start method, then no activity will occur even if we make a call to repaint. This is because the call to repaint calls update to call paint as soon as it can. That is, as soon as the controlling environment (browser/appletviewer) regains control to be able to call update. This is because the browser/appletviewer is running in what is called a thread.

A thread is a single sequential flow of execution. The browser/appletviewer is running in its own thread and can only make a call to the paint method one it has control of the thread. If the code in the start method contains an infinite loop or code that takes a very long time to execute, then the browser/appletviewer may not be able to regain control of the thread.

To solve this problem we must run the Applet in its own thread so that the two threads can execute simultaneously. Since the CPU can only do one thing at a time, the OS will simulate simultaneous execution by quickly swapping the two threads in and out of the CPU.

There is a class called Thread in the java.lang package. Since applets must extend the Applet class, and Java does not support multiple inheritance we cause an applet to run in its own thread by implementing an interface called Runnable. The Thread class itself implements the Runnable interface. The Runnable interface contains one method, public void run().

There are several class methods in the Thread class which we can use.

public void start() - starts a Thread running and calls the run() method

public void suspend() - suspends the execution of the Thread

public void resume() - resumes execution of the Thread

public void stop() - stops the Thread permanently

public void sleep(int milliseconds) - pauses execution of the Thread for the specified number of milliseconds. This method must be placed inside a try block and you must have a catch block to handle an InterruptedException. This can occur if the user exits the browser/appletviewer while the thread is sleeping

Recall that these methods are not run on their own. The first four are instance methods in the Thread class, and sleep is a class method in the Thread class.

In order to create a new instance of a thread we make a call to the constructor of the Thread class. This constructor has a parameter which is of type Runnable. Since Runnable is an interface any object which is instantiated from a class which implements Runnable is a valid object of type Runnable. We have seen class in which the call to the Thread constructor resembled the following.

thread = new Thread(this);
This is only valid if the current class implements the Runnable interface. As we have seen we can place inner classes in our applet which are themselves Runnable and can instantiate Threads using object of these inner classes as a parameter. The Applet does not need to implement the Runnable interface. If it does not, then sending this as a parameter to the constructor of the Thread class is not valid. For example, suppose we have an inner class called Timer which implements the Runnable interface. To create a new thread in which to run an instance of Timer we could use the following code.

thread = new Thread(new Timer());
Normally the init method is used to start a thread. The initial value of a thread is null until it is assigned a new instance of Thread. Normally the destroy method is used to stop a thread and then nullify it to free system resources.

On Wednesday we will begin talking about Data Structures.