Java Coffee Break Newsletter Volume 2, Issue 1 http://www.davidreilly.com/jcb/ ISSN 1442-3790 ========================================================================= In this issue * Java Book Selections * Article : Unraveling threads * Q&A : How do I use stacks? * Q&A : How do I detect if command line arguments are empty? ========================================================================= Java Book Selections With the release of Java 1.2, and the SWING/JFC packages, even experts have a little catching up to do - let alone beginners! We thought this selection of books might help you get up to speed. There's nothing like a book, whether to learn new concepts and techniques, or as a desktop reference to consult as you program. You can order these books from your local bookstore, or online for convenience through Amazon.com Core Java Foundation Classes by Kim Topley Review courtesy of Amazon.com With the arrival of Sun's Java Foundation Classes (JFC), developers can write Java applications that behave just like "native"-style applications, such as those written in Windows. Core Java Foundation Classes shows you how you can take advantage of the new JFC Swing classes to create Java applications with all the advanced features that today's users expect. After a tour of the JFC/Swing packages, the author jumps right into building basic Swing applications, focusing on layout managers (which control the arrangement of JFC components onscreen) and basic graphics programming. The book aims to let you create sophisticated Java applications, and so the author discusses topics such as menus and the toolbar, keyboard handling (and mouseless operation), and dialog boxes to let you do this. The book also covers powerful Swing components, the tree and table controls. The author even looks at creating multiple document interface (MDI) applications. --Richard Dragan [more] http://www.davidreilly.com/goto.cgi?isbn=0130803014 Graphic Java 1.2, Mastering the Jfc : Swing (Java Series , Vol 2) by David Geary Review courtesy of Amazon.com Java developers know that the Abstract Windowing Toolkit (AWT) is still an effective way to build functional user interfaces, whether inside Web browsers or in stand-alone applications. David Geary's guide to AWT programming in Graphic Java 1.2 shows you all the basics of AWT newly refitted for the new Java Developer's Kit (JDK) 1.2 standard from Sun, including some excellent 2-D animation examples. After introducing the basics of the AWT library, the author looks at simple painting and 2-D graphics. Standout sections here look at displaying images--a staple of Internet programming--as well as transforming images with "filters" (such as dimming and rescaling an image). Graphic Java 1.2 shows you a variety of advanced techniques for getting control of your bit-mapped content. The tour of Java graphics capabilities moves on with coverage of layout managers and basic AWT components such as buttons, text fields, lists, and choices. For those who want to create stand-alone Java applications, there's much material on using Java menus. The book's advanced material highlights new features of JDK 1.2, such as its support for lightweight controls, built-in double-buffering support, and advanced "native-style" operations (such as clipboard support and "rubber-banding" classes). The author also shows off his custom classes for 2-D sprite animation. --Richard Dragan [more] http://www.davidreilly.com/goto.cgi?isbn=0130796662 Java Swing by Robert Eckstein, Marc Loy & David Wood Review courtesy of Amazon.com Java Swing is an excellent introduction to the latest developments in Java-interface technology. The authors explain how (and why) to use Swing components, and meanwhile proceed to document the entire Swing API with the thoroughness and accuracy programmers have come to expect from O'Reilly & Associates. Eckstein, Loy, and Wood start with an architectural overview of Swing and its relationship to the Abstract Window Toolkit (AWT) and the rest of Java. They talk a little bit about converting programs from the old AWT to the Swing-enhanced AWT, and explain how Swing manages components' "look and feel" characteristics. There's also coverage of actions, which are among Swing's handiest new features. From that point, they proceed to guide readers through the Swing forest, pointing out all the important stuff along the way. Mostly, this tour takes the form of graphical user interface (GUI) component documentation, with chapters devoted to buttons, lists, tables, panes, and the other thingamajigs you can put on-screen with Swing. All the classes in each category get entries, many of which include good commentary and some examples. The authors give some attention to the Accessibility API and its associated utilities, too. A detailed chapter that walks the reader through the process of creating a custom look and feel distinguishes Java Swing from its competitors - this potentially confusing process is explained clearly and thoroughly. --David Wall [more] http://www.davidreilly.com/goto.cgi?isbn=156592455X Java 1.2 Unleashed by Jamie Jaworski The "Java Unleashed" series of books have been an extremely popular, not to mention extremely useful series. As references, and instructional guides, the "Java Unleashed" series are an invaluable resource. The latest in the line, "Java 1.2 Unleashed" is no exception - covering a wide range of new topics, such as SWING/JFC, Java-Media Framework, networking, RMI & CORBA. A great guide for intermediate to advanced developers. [more] http://www.davidreilly.com/goto.cgi?isbn=1575213893 Just Java 1.2 by Peter van der Linden "Just Java 1.2" is the sequel to the incredibly popular "Just Java" by Peter van der Linden, author of the "Java Programmers FAQ". Just published, this book is one of the most up-to-date Java 1.2 resource. [more] http://www.davidreilly.com/goto.cgi?isbn=0130105341 Upcoming titles Here are a selection of titles that are scheduled for release in the next few months. You might like to keep your eyes out for these at your local bookstore, or you can order advance copies online through Amazon.com. The Jfc Swing Components : A Tutorial Guide for Constructing Gui's by Kathy Walrath http://www.davidreilly.com/goto.cgi?isbn=0201433214 Pure Jfc : The Swing Toolkit (The Pure Series) by Satyaraj Pantham http://www.davidreilly.com/goto.cgi?isbn=0672314231 Swing Reference : User Interfaces With Java Foundation Classes by Stephen C. Drye, http://www.davidreilly.com/goto.cgi?isbn=1884777678 Jfc Unleashed (The Unleashed Series) by Michael Foley, http://www.davidreilly.com/goto.cgi?isbn=0789714663 Java Foundation Classes in a Nutshell : A Desktop Quick Reference for Java Programmers by David Flanagan http://www.davidreilly.com/goto.cgi?isbn=1565924886 ========================================================================= Unraveling threads Multi-threaded programming offers developers substantial advantages, and users increased performance. Despite the obvious benefits, novice programmers are reluctant to write multi-threaded applications because of their perceived complexity. This article will offer a gentle introduction to multi-threaded programming, as well as offering solutions for synchronization of threads. So, what exactly are threads? Threads are multiple instances of an application or applet that execute concurrently. Woah! That's a mouthful isn't it. Let's break it down a little. When we start an application, it executes in its own process - it has its own chunk of memory for data storage, and it runs alongside other processes. Modern operating systems (such as Windows, and Unix) create the illusion that these processes are running concurrently. A process can execute at the same time as another process, and the operating shares time between all running processes (though not always evenly). Each process represents a single thread of execution. Now a multi-threaded application is a special kind of application. It uses only a single process, but that process has multiple threads of execution. The same code and data is used, but we have more than one instance of the application running. Each thread runs concurrently, so when one thread is idle (perhaps waiting for data input), another thread can be performing some useful task. Easy huh? What can threads do? Threads are extremely useful, because they allow developers to write applications that are more responsive to the user. When your application is processing data, its poor design for the user-interface to be disabled until the task is complete. If your application is single-threaded, the user-interface can't respond to user commands if the application is performing another task. Furthermore, applications can their idle time to process things behind the scenes. For example, an applet that displays some animation can be preparing the next frame. So how do I use threads? Threads are actually quite easy to use, provided you do a little planning. First you have to identify the tasks a thread will perform. Usually your thread(s) will perform processing, allowing your primary thread to handle user-interface events. Once you've identified a task, you have to write the code for your thread. Our example will be an applet that displays a simple text scrolling animation. We'll create a new thread to create the animation, leaving our application free to respond to the user interface. When a user clicks on the applet, animation stops. When the mouse button is released, the animation resumes. Other than these two actions, all our applet does is launch a second thread to perform the animation. Let's look at the thread specific code. Creating a new thread Creating a new thread is pretty simple, and takes only a few lines of code. In our example, the new thread is created in the applet's start() method. We first check to see if an animation thread is already running, and if not, create one.     // Pass our thread an instance of java.lang.Runnable (us)     AnimationThread = new Thread(this); Notice the parameter we use when creating a new Thread object. This form of constructor accepts an instance of java.lang.Runnable, which is an interface our applet implements. We'll see how this works later, but for those who are curious, it is an interface that indicates our applet has work a thread can perform. We use the this keyword to indicate that the current class/object is being referred to. Next, we call that thread's start method. Once started, a thread will execute independently, until it completes its task, or the thread is suspended or stopped. Here's the full code for our start method. // Check to see if thread is active if (AnimationThread == null) {     // Pass our thread an instance of java.lang.Runnable (us)     AnimationThread = new Thread(this);     // Start the thread     AnimationThread.start(); } For the full article, including an example applet and source code, see http://www.davidreilly.com/jcb/articles/threads/ ========================================================================= Q&A : How do I detect if command line arguments are empty? Whenever you write Java applications, its vital that you check your command line arguments before using them. Not all users will remember to put in the correct number of parameters, and your application will terminate with an ArrayIndexOutOfBoundsException. Fortunately, its extremely easy to check! Here's an example program, that checks that at least one parameter exists : public class argsdemo { public static void main(String args[]) { if (args.length == 0) { System.err.println ("No arguments!"); System.exit(0); } } } Just add a if statement before using a parameter, and then perhaps exit with a message. You can check for a specific number of parameters, and terminate if they're missing. ========================================================================= Q&A : How do I use stacks in Java? A stack is a data structure that allows data to be inserted (a 'push' operation), and removed (a 'pop' operation). Many stacks also support a read ahead (a 'peek' operation), which reads data without removing it. A stack is a LIFO-queue, meaning that the last data to be inserted will be the first data to be removed. When we insert data into a stack, it is placed at the head of a queue. This means that when we remove data, it will be in reverse order. Adding 1,2,3,4 will return 4,3,2,1. Stacks aren't the most frequently used data structure, but they are extremely useful for certain tasks. +-------+ +-------+ + 3 + + 4 + + 2 + + 3 + + 1 + + 2 + +-------+ + 1 + +-------+ Figure 1.1 Stack before push operation, and stack after +-------+ +-------+ + 4 + + 3 + + 3 + + 2 + + 2 + + 1 + + 1 + +-------+ +-------+ Figure 1.1 Stack before pop operation, and stack after Java provides a stack implementation, in the form of java.util.Stack. Stack's are a subclass of java.util.Vector, and share some similarities. A Vector, after all, is a queue, and a Stack is an ordered LIFO queue. Stacks are quite easy to use. Here's a sample application that uses a stack to reverse a list of numbers. import java.util.Stack; public class StackDemo { public static void main(String args[]) { // Create a new, empty stack Stack lifo = new Stack(); // Let's add some items to it for (int i = 1; i <= 10; i++) { lifo.push ( new Integer(i) ); } // Last in first out means reverse order while ( !lifo.empty() ) { System.out.print ( lifo.pop() ); System.out.print ( ',' ); } // Empty, let's lift off! System.out.println (" LIFT-OFF!"); } } For more information, see the Java documentation for java.util.Stack. ========================================================================= The Java Coffee Break Newsletter is only sent out to email subscribers who have requested it, and to readers of the comp.lang.java.programmer and comp.lang.java.help newsgroups. If you'd like to receive our newsletter, and get the latest Java news, tips and articles from our site, then get your FREE subscription from http://www.davidreilly.com/jcb/newsletter/ If you are an email subscriber and no longer wish to receive the JCB Newsletter, please unsubscribe using the WWW form located at http://www.davidreilly.com/jcb/newsletter/unsubscribe.html