Notice: This material is excerpted from Special Edition Using Java, ISBN: 0-7897-0604-0. The electronic version of this material has not been through the final proof reading stage that the book goes through before being published in printed form. Some errors may exist here that are corrected before the book is published. This material is provided "as is" without any warranty of any kind.
by Mark Wutka
Now that you have learned some of the fundamentals of Java programming, you can concentrate on design issues that will help you create better programs in less time. Writing object-oriented software is not a skill that can be learned overnight. As you begin to realize some of the benefits that object-oriented software brings you, you will start learning to consider these benefits when you first start to write a program. Pretty soon, it will become second-nature.
One thing you should always keep in mind is that just because a program is written in an object-oriented language, it is not necessarily an object-oriented program. It is just as easy to write bad code in Java as it is in C. You have to put some effort into the design of your code to realize the benefits of object-orientation.
Fortunately, you don't have to get it perfect the first time, just keep refining your code over and over. Pretty soon, you will have good object-oriented program. This chapter will help you understand some of the issues and techniques involved in improving your code and maximizing its reuse.
In this chapter you will learn:
One of the highly touted advantages of object-oriented languages is the reusability of code: you don't have to start from scratch every time you write a program. Smalltalk, for instance, comes with a large set of reusable objects that are available to a programmer from the start. These objects are well-designed and provide a large number of commonly used components. This core of objects is one of the reasons that software can be developed in Smalltalk so quickly. There is less new code to write. One thing to remember about creating reusable software is that you sometimes have to take a little extra time up front to realize the benefits of reuse later on.
Inheritance and encapsulation are two of the features of object-oriented languages that help support code reuse. Java supports both of these features, but you must still be careful in how you use them. Like other features, inheritance and encapsulation can be easily abused.
Inheritance is most often praised as the great instrument of reuse that sets object-oriented languages apart from the rest. Inheritance achieves reuse by taking an existing class as a basis and building on top of it-adding new functionality or changing existing functionality. Inheritance is a very visible form of reuse because it explicitly reuses existing code.
One question that comes up frequently is "How do I know when to create a subclass?" The following are a few rules of thumb to help you decide whether you should create a subclass of an existing class or write a new one:
Encapsulation is an equally useful concept for creating reusable code, but is overlooked by many because it requires more work up front. To reuse by encapsulation means creating a class that has a well-defined interface and performs a specific set of functions and is as self-sufficient as possible. A self-sufficient class contains all the information necessary to perform its job.
Whereas inheritance promotes reuse by actually reusing an existing class, encapsulation creates classes that can be used easily by many other classes. The Graphics class is a well-encapsulated, very reusable class. You use the Graphics class in many applets, yet you never have to create a subclass of it.
The real key to code reuse does not lie in inheritance, but in a large set of flexible classes. Many people have suggested that object-oriented programming will lead to the development of software IC's: software that is as easy to put into a new system as integrated circuits. In creating a new system, a hardware designer uses catalogs of existing components. These components have a well-defined interface and perform a specific set of functions. These are, for the most part, self-sufficient. Whether the software industry ever gets to that point is a hotly debated question that only time will tell.
Rather than trying to grasp all the issues in object-oriented programming all at once, you can start with a basic design problem, and see how different ideas affect your design. The design problem is this: Create an applet that scrolls a text string from right to left in a marquee style.
To create a marquee text, you need to keep track of the following items:
Your first try will probably look something like listing 22.1. The output from this applet is show in figure 22.1.
Listing 22.1 Source Code for SimpleMarqueeApplet.java
import java.awt.*;
import java.applet.*;
// SimpleMarqueeApplet
//
// This applet scrolls a text string from right to left like a
// marquee sign.
public class SimpleMarqueeApplet extends Applet implements Runnable
{
protected String scrollString; // the string to scroll
protected int stringX; // the current string position
protected Font scrollFont;
protected Color scrollColor;
protected int scrollDelay; // how many milliseconds between movement
protected int scrollIncrement; // how many pixels to scroll
protected Thread animThread;
protected Image offscreenImage; // for flicker prevention
protected Graphics offscreenGraphics; // for flicker prevention
// The init method sets up some default values. The applet provides methods
// to set each of the customizable values.
public void init()
{
scrollFont = new Font("TimesRoman", Font.BOLD, 24);
scrollString = "Welcome to the very plain, yet fun, Simple Marquee Applet.";
scrollColor = Color.blue;
scrollDelay = 100;
scrollIncrement = 2;
stringX = size().width;
// Create tbe off-screen image for double-buffering
offscreenImage = createImage(size().width, size().height);
offscreenGraphics = offscreenImage.getGraphics();
}
// The run method implements a timer that moves the string and then
// repaints the screen. It tries to keep the delay time constant by
// figuring out when the next tick should be and only sleeping for however
// much time is left.
public void run()
{
long nextTime, currTime;
Thread.currentThread().setPriority(Thread.NORM_PRIORITY);
while (true)
{
// figure out what time the next tick should occur
nextTime = System.currentTimeMillis() + scrollDelay;
// Scroll the string
moveString();
// Redraw the string
repaint();
// See what time it is now
currTime = System.currentTimeMillis();
// If we haven't gotten to the next tick, sleep for however many milliseconds
// are left until the next tick;
if (currTime < nextTime) {
try {
Thread.sleep((int)(nextTime - currTime));
} catch (Exception noSleep) {
}
}
}
}
// moveString updates the string's position
public void moveString()
{
stringX -= scrollIncrement;
}
// setScrollString changes the string that is being displayed
public void setScrollString(String newString)
{
scrollString = newString;
}
// setScrollIncrement changes the number of pixels the string is move each
// tick time.
public void setScrollIncrement(int increment)
{
scrollIncrement = increment;
}
// setScrollDelay changes the number of milliseconds between ticks
public void setScrollDelay(int delay)
{
scrollDelay = delay;
}
// setScrollFont sets the font for the scroll string
public void setScrollFont(Font newFont)
{
scrollFont = newFont;
}
// setScrollColor sets the color for the scroll string
public void setScrollColor(Color color)
{
scrollColor = color;
}
// paint redraws the string on the screen
public void paint(Graphics g)
{
FontMetrics currentMetrics;
g.setFont(scrollFont);
g.setColor(scrollColor);
currentMetrics = g.getFontMetrics();
// If the left coordinate of the string is so far to the left that the
// string won't be displayed, move it over to the right again.
if (stringX < -currentMetrics.stringWidth(scrollString))
{
stringX = size().width;
}
else
{
// Compute the baseline as the ascent plus a padding of 5 pixels. This
// means there should be a clearance of 5 pixels between the tallest letter
// and the top of the drawing area.
int stringBaseline = currentMetrics.getAscent()+5;
g.drawString(scrollString, stringX, stringBaseline);
}
}
// This update method uses an off-screen drawing area to reduce applet
// flicker. It enables the paint method to assume a cleared screen by
// clearing the off-screen drawing area before calling paint.
public void update(Graphics g)
{
offscreenGraphics.setColor(getBackground());
offscreenGraphics.fillRect(0, 0, size().width,
size().height);
offscreenGraphics.setColor(g.getColor());
paint(offscreenGraphics);
g.drawImage(offscreenImage, 0, 0, this);
}
public void start()
{
animThread = new Thread(this);
animThread.start();
}
public void stop()
{
animThread.stop();
animThread = null;
}
}
fig. 22.1 SimpleMarqueeApplet scrolls text from right to left.
One of the first things you should realize about this applet is that it is not very reusable. One of the problems is that it is one big applet, making it difficult to use this functionality in another applet. For instance, suppose you wanted to make a stock trading applet and you wanted to have stock quotes scrolling across the bottom. In order to use this marquee code, you would have to create a subclass of the SimpleMarqueeApplet. That would be a case of subclassing for the wrong reason. The stock trading program is not a kind of marquee, it is something completely different.
Avoid putting all your code into one big applet; concentrate instead on making smaller pieces that can be reused. Your applet should make use of smaller classes while adding as little functionality as possible.
It is useful to think of objects as employees. One of the popular management buzzwords these days is employee empowerment. When you empower employees, you give them the authority to perform their jobs, and you trust them to complete their assignments without any interference from supervisors. In the world of objects, you want to "empower" your objects. Give them a specific role and trust them to do it.
Unfortunately, many programmers (and many more managers) do not subscribe to the idea of empowerment. When a manager does not empower the employees, the employees must come through him or her for all decisions. In the programming world, when the objects are not empowered, the applet becomes the big controlling force, only using other objects for simple tasks.
From a reuse standpoint, this is a bad thing. When you put all of your program logic into one big applet, it becomes difficult to reuse portions of it. For instance, suppose car engines were built as one huge part. You could not go down to a junkyard and pick up an old carburetor to replace a bad part.
One of the difficulties with object-oriented programming is figuring out how to split an object into smaller objects. Many times, looking at a description of what an object does can help you break the object into more specialized components.
If you are having difficulty identifying the subobjects that make up an object, try writing out a description of what the object does and look at the nouns in the description. These are often the subobjects.
The description of the marquee applet earlier was that it scrolls a text string from right to left in a marquee style. Wouldn't it be better if the text string knew how to scroll itself? The applet's only job would be to create the marquee text. Any other applet that wanted to have marquee text could also use the marquee text class.
Remember that object-oriented programming focuses on the interaction of small, "intelligent" objects, not single monolithic programs.
Your goal with the SimpleMarqueeString class is to create a text string that can somehow scroll itself from right to left and be used by many applets. In fact, you want to make it as easy to use as the Button or the Label from the AWT library. You can do that by making the SimpleMarqueeString a subclass of a Canvas. Recall that in the SimpleMarqueeApplet, you used a thread to create a timer for moving the string. Because you are moving the responsibility for displaying the string to the SimpleMarqueeString class, you move the timer as well.
Remember, you want the applet that uses the SimpleMarqueeString to do as little as possible to make it run. As it turns out, it does not take much effort to convert this applet into a Canvas. First, you need to change the declaration of the class:
public class SimpleMarqueeString extends Canvas implements Runnable
Now, you need two additional class variables: preferredWidth and preferredHeight. In an applet, the width and height are predetermined, but the Canvas needs some way of finding out how large you want it to be.
protected int preferredWidth; protected int preferredHeight;
Next, you need to create a constructor for the class. It is a good idea to provide a quick constructor for the most common usage and then a full constructor that enables you to set all the options. Listing 22.2 shows a quick constructor:
Listing 22.2 A quick constructor for SimpleMarqueeString
public SimpleMarqueeString(String string, int width, int height)
{
scrollString = string;
scrollFont = new Font("TimesRoman", Font.BOLD, 24);
scrollColor = Color.blue;
scrollDelay = 100;
scrollIncrement = 2;
preferredWidth = width;
preferredHeight = height;
stringX = width;
}
Listing 22.3 shows a full constructor that enables you to set all of the parameters:
Listing 22.3 A full constructor for the SimpleMarqueeString class
public SimpleMarqueeString(String string, int width, int height,
Color color, Font font, int delay, int increment)
{
scrollString = string;
scrollFont = font;
scrollColor = color;
scrollDelay = delay;
scrollIncrement = increment;
preferredWidth = width;
preferredHeight = height;
stringX = width;
}
You need a way to convey the preferred height and width to the layout manager in charge of this Canvas. You can define methods called preferredSize and minimumSize to do this:
public Dimension preferredSize()
{
return new Dimension(preferredWidth, preferredHeight);
}
public Dimension minimumSize()
{
return preferredSize();
}
Finally, creating an off-screen image is a little trickier with a Canvas because you cannot create the image reliably from the constructor. However, as shown in listing 22.4, you can create it in the update method:
Listing 22.4 A flicker-free update method for the SimpleMarqueeString class
public void update(Graphics g)
{
// create off-screen image if it doesn't exist
if (offscreenImage == null) {
offscreenImage = createImage(size().width,
size().height); // for flicker prevention
offscreenGraphics = offscreenImage.getGraphics();
}
offscreenGraphics.setColor(getBackground());
offscreenGraphics.fillRect(0, 0, size().width,
size().height);
offscreenGraphics.setColor(g.getColor());
paint(offscreenGraphics);
g.drawImage(offscreenImage, 0, 0, this);
}
(c)Making Flexible Classes
Another big key to creating reusable code is creating flexible classes. You wanted the text to scroll from right to left. Maybe someone else will want it to scroll from left to right-or maybe top to bottom. Maybe there should be options for changing speeds or making the text flash. It may take you a little extra time to add features like these, but remember: this is an investment. Two months later when you need to scroll text a different way, you'll be glad you put all those extra features in there-and so will the other people who use it.
Try to anticipate other uses for a class, and provide methods for them. The more options available, the more likely the class is to be reused.
You will often find that you greatly underestimated the ways someone might want to use a class that you designed. Many times, you will need to add a wider variety of parameters. You can either add new methods to accept these different parameters, or better yet, encapsulate the parameters in an object. Whenever you add features that require more parameters, you can make a subclass of the parameter object.
Try to group configuration parameters for a class into their own class, rather than continually changing and adding constructors. This enables you to expand the class functionality quickly without modifying its interface.
There are two schools of thought in how you update member variables in a class. The Smalltalk school suggests that you make all the variables private (or at least protected) and that you always access them through methods commonly referred to as accessor methods. The most common format is getVariableName and setVariableName. Of course, in Smalltalk, you have to access member variables this way-there is no other choice. The Direct Access school suggests just making them public. There are advantages and disadvantages to each approach.
Accessor methods enable you to react to a variable being changed. In other words, if you want an object to perform a series of actions whenever a certain variable is changed, you modify the set method for that variable. Unfortunately, it takes time to write accessor methods for each variable, and in very intensive algorithms, they can add some overhead.
Public variables, on the other hand, are much easier to use and do not add overhead during intense usage. They do make it more difficult to react to changes, however.
Use public variables in data-oriented objects, such as those encapsulating configuration parameters. Use accessor methods for any variable that could possibly trigger some action if changed.
The MarqueeItem class holds the parameters for scrolling a string in four directions: right to left, left to right, top to bottom, and bottom to top (see listing 22.2).
Listing 22.5 Source Code for MarqueeItem.java
import java.awt.*;
public class MarqueeItem extends Object
{
//
// Define some constants for describing the marquee
//
public static final int RIGHT_TO_LEFT = 1;
public static final int LEFT_TO_RIGHT = 2;
public static final int TOP_TO_BOTTOM = 3;
public static final int BOTTOM_TO_TOP = 4;
// Define the marquee item parameters
public String marqueeString; // The string to draw
public Color marqueeColor; // The string's color
public Font marqueeFont; // The string's font
public int scrollIncrement; // how much to move the string
public int scrollDelay; // how many milliseconds between moves
public int scrollDirection; // which way to move the string
// RIGHT_TO_LEFT, LEFT_TO_RIGHT, etc.
// Set up a constructor for creating a MarqueeItem quickly
public MarqueeItem(String string)
{
marqueeString = string;
marqueeColor = Color.blue;
marqueeFont = new Font("TimesRoman", Font.BOLD, 24);
scrollIncrement = 3;
scrollDelay = 100;
scrollDirection = RIGHT_TO_LEFT;
}
// Set up a full constructor for creating a MarqueeItem
public MarqueeItem(String string, Color color, Font font,
int increment, int delay, int direction)
{
marqueeString = string;
marqueeColor = color;
marqueeFont = font;
scrollIncrement = increment;
scrollDelay = delay;
scrollDirection = direction;
}
}
Now that you have an object to describe the marquee string and its direction, you can improve the SimpleMarqueeString class to scroll the text in multiple directions. The MarqueeString class is an improved version of SimpleMarqueeString, using the MarqueeItem class to configure the marquee string (see listing 22.6).
Listing 22.6 Source Code for MarqueeString1.java
import java.awt.*;
import java.applet.*;
// MarqueeString
//
// This canvas scrolls a text string from right to left like a
// marquee sign.
public class MarqueeString extends Canvas implements Runnable
{
protected MarqueeItem item;
protected int stringX; // the current string position
protected int stringBaseline; // the current string baseline
protected Thread animThread;
protected int preferredWidth;
protected int preferredHeight;
protected Image offscreenImage;
protected Graphics offscreenGraphics;
public MarqueeString(MarqueeItem newItem, int width, int height)
{
item = newItem;
preferredWidth = width;
preferredHeight = height;
setScrollPosition();
}
// Set scroll position sets the initial position for the scrolling string.
public void setScrollPosition()
{
switch (item.scrollDirection)
{
// For a right to left scroll, place it just off the screen to the right
case MarqueeItem.RIGHT_TO_LEFT:
stringX = preferredWidth;
break;
// For a left to right scroll, place the left end of the string on the
// left side of the screen. This would be better if you could put the
// whole string just off the left hand side of the screen, but at this
// point we may not be able to get the font metrics.
case MarqueeItem.LEFT_TO_RIGHT:
stringX = 0;
break;
// For a top to bottom scroll, place the string at the just off the top of
// the screen. Text that extends below the baseline will be immediately
// visible.
case MarqueeItem.TOP_TO_BOTTOM:
stringX = 0;
stringBaseline = 0;
break;
// For a bottom to top scroll, place the string just below the bottom of
// the screen.
case MarqueeItem.BOTTOM_TO_TOP:
stringX = 0;
stringBaseline = preferredHeight;
break;
// By default do a right to left scroll
default:
item.scrollDirection = MarqueeItem.RIGHT_TO_LEFT;
stringX = preferredWidth;
}
}
// Enable the item parameters to be changed on-the-fly. Reset the string
// position of the item changes.
public void setMarqueeItem(MarqueeItem newItem)
{
item = newItem;
setScrollPosition();
}
public Dimension preferredSize()
{
return new Dimension(preferredWidth, preferredHeight);
}
public Dimension minimumSize()
{
return preferredSize();
}
// The run method implements a timer that moves the string and then
// repaints the screen. It tries to keep the delay time constant by
// figuring out when the next tick should be and only sleeping for however
// much time is left.
public void run()
{
long nextTime, currTime;
Thread.currentThread().setPriority(Thread.NORM_PRIORITY);
while (true)
{
// figure out what time the next tick should occur
nextTime = System.currentTimeMillis() +
item.scrollDelay;
// Scroll the string
moveString();
// Redraw the string
repaint();
// See what time it is now
currTime = System.currentTimeMillis();
// If we haven't gotten to the next tick, sleep for however many milliseconds
// are left until the next tick;
if (currTime < nextTime) {
try {
Thread.sleep((int)(nextTime - currTime));
} catch (Exception noSleep) {
}
}
}
}
// moveString updates the string's position
public void moveString()
{
switch (item.scrollDirection)
{
case MarqueeItem.RIGHT_TO_LEFT:
stringX -= item.scrollIncrement;
break;
case MarqueeItem.LEFT_TO_RIGHT:
stringX += item.scrollIncrement;
break;
case MarqueeItem.TOP_TO_BOTTOM:
stringBaseline += item.scrollIncrement;
break;
case MarqueeItem.BOTTOM_TO_TOP:
stringBaseline -= item.scrollIncrement;
break;
}
}
// checkMarqueeBounds checks to see if the string goes completely off
// the screen, and if so, it moves the string to the other side of the
// screen. For the horizontal scrolls, it also computes the baseline
// each time.
public void checkMarqueeBounds(FontMetrics metrics)
{
switch (item.scrollDirection)
{
// For right to left, the string is off the screen when the x is less than
// the negative of the string width (i.e. x + width < 0)
case MarqueeItem.RIGHT_TO_LEFT:
if (stringX < -metrics.stringWidth(
item.marqueeString))
{
stringX = metrics.stringWidth(
item.marqueeString);
}
stringBaseline = metrics.getHeight() + 5;
return;
// for left to right, the string is off the screen when X goes past the
// width of the area.
case MarqueeItem.LEFT_TO_RIGHT:
if (stringX > preferredWidth)
{
stringX = -metrics.stringWidth(
item.marqueeString);
}
stringBaseline = metrics.getHeight() + 5;
return;
// For top to bottom, the string is off the screen when the baseline goes
// beyond the point where baseline + height is still within the screen
case MarqueeItem.TOP_TO_BOTTOM:
if (stringBaseline > preferredHeight +
metrics.getHeight()) {
stringBaseline = -metrics.getHeight();
}
return;
// For bottom to top, the string is off the screen when the baseline goes
// below the negative of the string height (baseline + height < 0)
case MarqueeItem.BOTTOM_TO_TOP:
if (stringBaseline < -metrics.getHeight()) {
stringBaseline = preferredHeight +
metrics.getHeight();
}
return;
}
}
// paint redraws the string on the screen
public void paint(Graphics g)
{
FontMetrics currentMetrics;
g.setFont(item.marqueeFont);
g.setColor(item.marqueeColor);
currentMetrics = g.getFontMetrics();
checkMarqueeBounds(currentMetrics);
g.drawString(item.marqueeString, stringX, stringBaseline);
}
// This update method uses an off-screen drawing area to reduce applet
// flicker. It enables the paint method to assume a cleared screen by
// clearing the off-screen drawing area before calling paint.
public void update(Graphics g)
{
// If the offScreenImage doesn't exist yet, create it
if (offscreenImage == null) {
offscreenImage = createImage(size().width,
size().height); // for flicker prevention
offscreenGraphics = offscreenImage.getGraphics();
}
offscreenGraphics.setColor(getBackground());
offscreenGraphics.fillRect(0, 0, size().width,
size().height);
offscreenGraphics.setColor(g.getColor());
paint(offscreenGraphics);
g.drawImage(offscreenImage, 0, 0, this);
}
public void start()
{
animThread = new Thread(this);
animThread.start();
}
public void stop()
{
animThread.stop();
animThread = null;
}
}
The MarqueeApplet class uses the MarqueeString class to display two different marquees. Notice that the applet still just creates the objects that do the work; it doesn't do anything special itself (see listing 22.7).
Listing 22.7 Source Code for MarqueeApplet1.java
import java.awt.*;
import java.applet.*;
// MarqueeApplet
//
// This applet scrolls two text strings one from right to left,
// the other from top to bottom.
public class MarqueeApplet1 extends Applet
{
MarqueeString marquee1;
MarqueeString marquee2;
public void init()
{
marquee1 = new MarqueeString(
new MarqueeItem("Welcome to the new and improved marquee!"), 300, 50);
add(marquee1);
marquee1.start();
marquee2 = new MarqueeString(
new MarqueeItem("This scrolls from top to bottom.",
Color.red, new Font("TimesRoman",
Font.PLAIN, 16), 1, 100,
MarqueeItem.TOP_TO_BOTTOM), 300, 100);
add(marquee2);
marquee2.start();
}
}
You will probably want to be able to change the text from time to time on the marquee. Because you don't want to change the text in the middle of the scrolling, you want the MarqueeString class to notify you when the text has finished scrolling. What you want here is a callback method. You set up a method in your applet and the MarqueeString class calls that method when it is finished displaying the text.
Use interfaces to implement callbacks. Interfaces define a set of methods that any object which implements that interface must provide. When you want to create a callback, create an interface that represents that callback, then any object that wants to be called back must implement the interface.
The MarqueeObserver interface defines a callback method that the MarqueeString class will call every time it finishes displaying a string (see listing 22.8).
Listing 22.8 Source Code for MarqueeObserver.java
public interface MarqueeObserver
{
// marqueeNotify is called whenever the item scrolls off the screen
public void marqueeNotify(MarqueeItem item);
}
The MarqueeString class needs to be modified to support this new callback. Whenever you change a class, you should be careful not to make it unusable for previous users in the class. In this case, you can add another constructor for the class that sets up the callback. This way, the original applet you wrote can still use the MarqueeString class with no changes.
When adding functionality to a class, try not to remove the existing constructors and methods. You don't want every new addition to break applets that use the class.
To add support for the MarqueeObserver interface to the MarqueeString, you need to add a variable for the observer:
protected MarqueeObserver observer;
Next, add a new constructor to create a MarqueeString with an observer, but leave the original constructor available for any old applets that may still use it. Listing 22.9 shows the new constructor:
Listing 22.9 A constructor for MarqueeString that supports a MarqueeObserver
public MarqueeString(MarqueeItem newItem, int width, int height,
MarqueeObserver newObserver)
{
preferredWidth = width;
preferredHeight = height;
setMarqueeItem(newItem);
observer = newObserver;
}
You should also add a method to set the observer manually just in case you want to change the observer after the MarqueeString has already been created:
public void setObserver(MarqueeObserver newObserver)
{
observer = newObserver;
}
Finally, change the checkMarqueeBounds method to call marqueeNotify if the string runs off the screen:
public void checkMarqueeBounds(FontMetrics metrics)
{
switch (item.scrollDirection)
{
// For right to left, the string is off the screen when the x is less than
// the negative of the string width (i.e. x + width < 0)
case MarqueeItem.RIGHT_TO_LEFT:
if (stringX < -metrics.stringWidth(
item.marqueeString))
{
stringX = metrics.stringWidth(
item.marqueeString);
if (observer != null) {
observer.marqueeNotify(item);
}
}
stringBaseline = metrics.getHeight() + 5;
return;
// for left to right, the string is off the screen when X goes past the
// width of the area.
case MarqueeItem.LEFT_TO_RIGHT:
if (stringX > preferredWidth)
{
stringX = -metrics.stringWidth(
item.marqueeString);
if (observer != null) {
observer.marqueeNotify(item);
}
}
stringBaseline = metrics.getHeight() + 5;
return;
// For top to bottom, the string is off the screen when the baseline goes
// beyond the point where baseline + height is still within the screen
case MarqueeItem.TOP_TO_BOTTOM:
if (stringBaseline > preferredHeight +
metrics.getHeight()) {
stringBaseline = -metrics.getHeight();
if (observer != null) {
observer.marqueeNotify(item);
}
}
return;
// For bottom to top, the string is off the screen when the baseline goes
// below the negative of the string height (baseline + height < 0)
case MarqueeItem.BOTTOM_TO_TOP:
if (stringBaseline < -metrics.getHeight()) {
stringBaseline = preferredHeight +
metrics.getHeight();
if (observer != null) {
observer.marqueeNotify(item);
}
}
return;
}
}
In addition to adding methods to a class, sometimes you can even encapsulate common mechanisms for using a class. You frequently perform the same operation on a group of classes. When you do, you should consider creating a class to encapsulate that operation or a group of similar operations. For instance, many applets will probably want to change the text once it has finished scrolling. You can create a driver that takes a number of MarqueeItem objects and automatically changes the marquee text whenever it finishes scrolling (see listing 22.10).
Any time you notice you are doing the same thing over and over, try to think of a way to capture it in a class. This is the essence of object-oriented programming.
Listing 22.10 Source Code for MarqueeDriver.java
// MarqueeDriver
//
// The marquee driver automatically cycles through an
// array of MarqueeItems feeding them to a MarqueeString
// whenever an item has scrolled off the screen.
public class MarqueeDriver extends Object implements MarqueeObserver
{
MarqueeItem items[];
MarqueeString marquee;
int currItem;
public MarqueeDriver(MarqueeString marqueeString, MarqueeItem newItems[])
{
items = newItems;
currItem = 0;
marquee = marqueeString;
// Ask the marquee string to notify us when an item scrolls off
marquee.setObserver(this);
}
public void marqueeNotify(MarqueeItem item)
{
currItem++; // goto next item
// If we get to the end, start back at the beginning
if (currItem >= items.length)
{
currItem = 0;
}
// Change the item in the marquee string
marquee.setMarqueeItem(items[currItem]);
}
}
So far, the applets in this chapter have only created a few objects and set them in action. You can add flexibility to your applets by passing them parameters from HTML using the <PARAM> tag. The applet uses the getParameter method to retrieve parameters passed through <PARAM>.
Parameters are not the only way to make an applet-or any other class-extensible. Inheritance is a useful way of adding functionality to a class, but the class should be designed with inheritance in mind.
Try to break up each action an object performs into separate methods. When you want to change a single action, you should be able to override a single method in the subclass and not affect the rest of the original object.
In a class, such as an applet, pay particular attention to methods that create instances of objects. Try to separate the creation of the instance into a separate method. For example, if you have a method that parses parameters from the getParameters method and then creates an instance of another object, try to separate the creation of the object into a separate method. This is especially useful when creating objects that are likely to be subclassed at some time.
The following applet creates a number of MarqueeItems based on parameters passed via the <PARAM> tag, as well as a MarqueeDriver to cycle through the parameters (see listing 22.11).
Listing 22.11 Source Code for MarqueeApplet.java
import java.awt.*;
import java.applet.*;
// MarqueeApplet
//
// This applet scrolls a text string from right to left like a
// marquee sign. It is configurable via the <PARAM> tag in HTML.
// For each marquee string, the parameters are:
// marqueeName - the string to be displayed
// marqueeFont - the name of the font to use
// marqueeFontHeight - the point height of the font to use
// marqueeFontPlain - if this param is present, make the font plain
// marqueeFontBold - if this param is present, make the font bold
// marqueeFontItalic - if this param is present, make the font bold
// You can specify more than one of the plain/bold/italic parameters
// to get combinations like Bold+Italic
// marqueeColor - the color of the text, either a name or an integer RGB value
// scrollIncrement - the number of pixels to scroll each time
// scrollDelay - the number of millisecond to delay between successive scrolls
// scrollDirection - either topToBottom, bottomToTop, leftToRight or
// rightToLeft
//
// Each of these parameter names should be followed immediately by a number
// indicating which item it is for. For instance, to set the marqueeName
// for the first item, the <PARAM> tag would be:
// <PARAM name="marqueeName0" value="This is the first entry">
// the second item would be:
// <PARAM name="marqueeName1" value="This is the second entry">
//
public class MarqueeApplet extends Applet
{
// Set up some arrays to map names to colors
public static final String colorNames[] = {
"white", "lightGray", "gray", "darkGray", "black",
"red", "pink", "orange", "yellow", "green",
"magenta", "cyan", "blue"
};
public static final Color colorValues[] = {
Color.white, Color.lightGray, Color.gray, Color.darkGray,
Color.black, Color.red, Color.pink, Color.orange,
Color.yellow, Color.green, Color.magenta, Color.cyan,
Color.blue
};
// Set up some arrays to map direction names to directions
public static final String directionNames[] = {
"topToBottom", "bottomToTop", "leftToRight", "rightToLeft"
};
public static final int directions[] = {
MarqueeItem.TOP_TO_BOTTOM, MarqueeItem.BOTTOM_TO_TOP,
MarqueeItem.LEFT_TO_RIGHT, MarqueeItem.RIGHT_TO_LEFT
};
MarqueeString marquee;
MarqueeItem items[];
MarqueeDriver driver;
public void init()
{
int i, numParams;
// First, figure out how many parameters there are
numParams = 0;
while (true)
{
// Stop counting when fetchParameter returns null (which means the
// parameter didn't exist).
if (fetchParameter("marqueeString", numParams) == null)
{
break;
}
numParams++;
}
// Now, create an array of items long enough to hold all the strings
items = new MarqueeItem[numParams];
// Now, loop again and create all the items.
for (i=0; i < numParams; i++)
{
items[i] = fetchMarqueeItem(i);
}
// If there were no items, be gentle - scroll out a message saying so
if (items.length == 0)
{
items = new MarqueeItem[1];
items[0] = new MarqueeItem(
"No parameters were supplied for this marquee :-(");
}
marquee = createMarqueeString(items[0], 300, 300);
add(marquee);
marquee.start();
driver = createMarqueeDriver(marquee, items);
}
// getIntParameter tries to convert a string to an integer. If the
// conversion isn't successful, return the defaultValue that was
// passed in.
public int getIntParameter(String str, int defaultValue)
{
int radix = 10;
String convertString = str;
// If the string starts with 0x, it is a hex number
if ((str.length() > 2) && (str.substring(0, 2).equals("0x") ||
str.substring(0, 2).equals("0X")))
{
radix = 16;
convertString = str.substring(2); // ignore the 0x now
}
// otherwise, if it starts with 0, it is an octal number
else if ((str.length() > 1) && (str.substring(0, 1).equals("0")))
{
radix = 8;
convertString = str.substring(1); // ignore the 0 now
}
// try to convert the string to an integer
try {
return Integer.parseInt(convertString, radix);
} catch (Exception badConversion) {
// if there was a conversion error, return the default value
return defaultValue;
}
}
// fetchParameter tries to retrieve an applet parameter. If the
// parameter is unavailable, it returns null.
public String fetchParameter(String paramPrefix, int index)
{
String paramName = paramPrefix+index;
try {
return getParameter(paramName);
} catch (Exception noparameter) {
return null;
}
}
// Create an instance of a MarqueeItem - this enables subclasses
// of this applet to change the creation of MarqueeItems
public MarqueeItem createMarqueeItem(String name,
Color color, Font font, int increment, int delay,
int direction)
{
return new MarqueeItem(name, color, font, increment,
delay, direction);
}
// Create an instance of a MarqueeString - this enables subclasses
// of this applet to change the creation of MarqueeStrings
public MarqueeString createMarqueeString(MarqueeItem item,
int preferredWidth, int preferredHeight)
{
return new MarqueeString(item, preferredWidth,
preferredHeight);
}
// Create an instance of a MarqueeDriver - this enables subclasses
// of this applet to change the creation of MarqueeDrivers
public MarqueeDriver createMarqueeDriver(MarqueeString marquee,
MarqueeItem items[])
{
return new MarqueeDriver(marquee, items);
}
public MarqueeItem fetchMarqueeItem(int itemNumber)
{
int i;
String parameter;
String marqueeName;
String fontName;
int fontStyle;
int fontHeight;
int colorValue;
Color color;
int increment;
int delay;
int direction;
marqueeName = fetchParameter("marqueeString", itemNumber);
// Try getting the font, if not there, default to TimesRoman
fontName = fetchParameter("marqueeFont", itemNumber);
if (fontName == null)
{
fontName = "TimesRoman";
}
// Try getting the font height, otherwise, default to 24
parameter = fetchParameter("marqueeFontHeight", itemNumber);
if (parameter == null)
{
fontHeight = 24;
}
else
{
fontHeight = getIntParameter(parameter, 24);
}
// Check for the font style parameters
fontStyle = 0;
if (fetchParameter("marqueeFontPlain", itemNumber) != null)
{
fontStyle += Font.PLAIN;
}
if (fetchParameter("marqueeFontBold", itemNumber) != null)
{
fontStyle += Font.BOLD;
}
if (fetchParameter("marqueeFontItalic", itemNumber) != null)
{
fontStyle += Font.ITALIC;
}
// Try getting the marquee color, default to black if not present
parameter = fetchParameter("marqueeColor", itemNumber);
if (parameter == null)
{
color = Color.black;
}
else
{
color = null;
// Try checking to see if it is a color name, first
for (i=0; i < colorNames.length; i++)
{
if (colorNames[i].equals(parameter))
{
color = colorValues[i];
break;
}
}
// Otherwise, assume it is an RGB value, default to 0 if not a valid integer
if (color == null)
{
color = new Color(
getIntParameter(parameter, 0));
}
}
// try getting the scroll increment, default to 3 if not present
parameter = fetchParameter("scrollIncrement", itemNumber);
if (parameter == null)
{
increment = 3;
}
else
{
increment = getIntParameter(parameter, 3);
}
// try getting the scroll delay, default to 100 if not present
parameter = fetchParameter("scrollDelay", itemNumber);
if (parameter == null)
{
delay = 100;
}
else
{
delay = getIntParameter(parameter, 100);
}
// try getting the scroll direction, default to RIGHT_TO_LEFT if not present
parameter = fetchParameter("scrollDirection", itemNumber);
direction = MarqueeItem.RIGHT_TO_LEFT;
if (parameter != null)
{
for (i=0; i < directionNames.length; i++)
{
if (parameter.equals(directionNames[i]))
{
direction = directions[i];
break;
}
}
}
// Create a new marquee item
return createMarqueeItem(marqueeName, color,
new Font(fontName, fontStyle, fontHeight),
increment, delay, direction);
}
}
One of the nice features of Java is its support for multimedia applications. You can add sound to an applet through the getAudioClip method. Once you have an audio clip, you can play it with the play method, stop playing it with the stop method, or play it in a continuous loop with the loop method. You can add sound to the marquee very easily. Remember, back in the section titled "Making Flexible Classes," how all the marquee parameters were stored in a class called MarqueeItem? You can add audio parameters by creating an AudioMarqueeItem subclass (see listing 22.12).
Listing 22.12 Source Code for AudioMarqueeItem.java
import java.applet.*;
import java.awt.*;
public class AudioMarqueeItem extends MarqueeItem
{
public AudioClip audioClip; // the audio clip to play
public boolean loopClip; // should it be played once or looped?
AudioMarqueeItem(String string, AudioClip clip, boolean loop)
{
super(string);
audioClip = clip;
loopClip = loop;
}
// Set up a full constructor for creating a AudioMarqueeItem
public AudioMarqueeItem(String string, Color color, Font font,
int increment, int delay, int direction, AudioClip clip,
boolean loop)
{
super(string, color, font, increment, delay, direction);
audioClip = clip;
loopClip = loop;
}
}
The AudioMarqueeItem is a good example of adding additional parameters in a non-intrusive way. You can still pass an AudioMarqueeItem to the MarqueeString class; the audio information will just be ignored. To make use of the audio information in the AudioMarqueeItem, you need to make a version of the MarqueeString that supports it (see listing 22.13).
Listing 22.13 Source Code for AudioMarqueeString.java
import java.awt.*;
import java.applet.*;
// AudioMarqueeString
//
// This canvas scrolls a text string from right to left like a
// marquee sign. It will also play audio clips along with the
// text.
public class AudioMarqueeString extends MarqueeString
{
AudioClip currentClip; // the clip currently playing
// The constructors for AudioMarqueeString are identical to those in
// MarqueeString because the audio-specific items are in the AudioMarqueeItem.
public AudioMarqueeString(MarqueeItem newItem, int width, int height)
{
super(newItem, width, height);
}
public AudioMarqueeString(MarqueeItem newItem, int width, int height,
MarqueeObserver newObserver)
{
super(newItem, width, height, newObserver);
}
// When the item changes, check to see if the new one is an audio item
// and if so, play its audio clip if it has one.
public synchronized void setMarqueeItem(MarqueeItem newItem)
{
// Stop playing the old clip if we were playing one
if (currentClip != null)
{
currentClip.stop();
}
// change the marquee item in the super class
super.setMarqueeItem(newItem);
// Check to see if this is an audio item
if (newItem instanceof AudioMarqueeItem)
{
AudioMarqueeItem audioItem = (AudioMarqueeItem)newItem;
// Now see if it has an audio clip
if (audioItem.audioClip != null)
{
currentClip = audioItem.audioClip;
if (audioItem.loopClip)
{
currentClip.loop();
}
else
{
currentClip.play();
}
}
}
}
}
Notice how the AudioMarqueeString class deals almost exclusively with playing audio and is able to leave the rest up to the super class. One of the reasons that it requires so little code to add audio to the MarqueeString is that there is a special method called when the marquee item changes. This is a good example showing why you should try to separate the actions into separate methods. All you need now to play audio clips is an applet that creates an AudioMarqueeString (see listing 22.14).
Listing 22.14 Source Code for AudioMarqueeApplet.java
import java.awt.*;
import java.applet.*;
// AudioMarqueeApplet
//
// This applet scrolls a text string from right to left like a
// marquee sign.
public class AudioMarqueeApplet extends MarqueeApplet
{
public MarqueeItem createMarqueeItem(String marqueeName,
Color color, Font font, int increment, int delay,
int direction)
{
return new AudioMarqueeItem(marqueeName, color, font,
increment, delay, direction,
(AudioClip)null, false);
}
public MarqueeString createMarqueeString(MarqueeItem item,
int preferredWidth, int preferredHeight)
{
return new AudioMarqueeString(item, preferredWidth,
preferredHeight);
}
public MarqueeItem fetchMarqueeItem(int itemNumber)
{
// The fetchMarqueeItem in the super class SHOULD return an AudioMarqueeItem
// because it will call createMarqueeItem, which this class overloads to create
// an AudioMarqueeItem.
MarqueeItem originalItem = super.fetchMarqueeItem(itemNumber);
// Now, just in case something went wrong and originalItem is not an
// instance of an AudioMarqueeItem, just return it and ignore the
// audio parameters
if (!(originalItem instanceof AudioMarqueeItem))
{
return originalItem;
}
AudioMarqueeItem item = (AudioMarqueeItem) originalItem;
// Get the name of the audio clip to play
String clipName = fetchParameter("audioClip", itemNumber);
if (clipName != null)
{
// Try to load the clip
item.audioClip = getAudioClip(getDocumentBase(),
clipName);
}
// See if the clip should loop or not
if (fetchParameter("loopAudioClip", itemNumber) != null)
{
item.loopClip = true;
}
else
{
item.loopClip = false;
}
return item;
}
}
Notice how easily the AudioMarqueeApplet adds audio support to the MarqueeApplet. Because the MarqueeApplet uses separate methods for creating the different objects it uses, it is simple to make it use different objects. Likewise, because it has a separate method for reading the parameters for an item, it is easy to add support for additional parameters.
For technical support for our books and software contact support@mcp.com
Copyright ©1996, Que Corporation