Introduction to the Java Foundation Classes

Introduction to the Java Foundation Classes Topics in This Chapter • The History of the Java Foundation Classes • Overview of JFC Features • The Swing Packages • Look-and-Feel and the Model-View-Controller Architecture 1 ChapterChapter he Java Foundation Classes bring new capabilities to the Java programmer, foremost among which are the components in the so-called Swing set. This Tchapter begins by looking briefly at the history of the Java programming language and of the Abstract Window Toolkit in particular. The Abstract Window Toolkit, or AWT for short, provides the classes used to build an application’s user interface. In both Java Development Kit (JDK) 1.0 and JDK 1.1, Java applications running under Windows looked just like Windows programs, while those running on Solaris looked the same as native applications written with the Motif toolkit. The reason for this was simply that much of the AWT is provided by code from the native platform’s windowing system—the user interface components are rendered by Windows or by Motif, not by Java code. While this has its advantages, it also has drawbacks. For one thing, it is difficult to implement a single interface and map it to two (or more) host platforms that work differently. And even when you’ve done that, the controls themselves behave somewhat differently between the platforms. Because this behavior is part of the native windowing system, there’s nothing you can do about it. Implementing all of the user interface classes in Java gets rid of these problems at a stroke. That’s exactly what the Swing components, which are the most significant part of the Java Foundation Classes (JFC), do—they replace the native implementation with a user interface library that works the same on all Java platforms. This chapter starts by looking at the history of the Swing project and then moves on to look at the new architecture that was developed to implement the Swing controls. The power of this architecture will be shown toward the end of the chapter, when you’ll see how simple it is to change the way an application built with Swing controls looks, without changing a single line of code. 5 6 Chapter 1 Introduction to the Java Foundation Classes What Are the Java Foundation Classes? The Java Foundation Classes are a group of features whose implementation began with JDK 1.1 and is continued in JDK 1.2, one of the most significant parts of which, and the main concern of this book, is the Swing component set. The Swing components are all graphical user interface controls that replace most of the platform-native components provided by the JDK 1.0 and JDK 1.1 AWT. The best way to understand what the Swing components are and how they will affect the development of Java applications is to look at how the Swing project came about and at the problems with the AWT that Swing is intended to address. In the Beginning:The Abstract Window Toolkit Sun Microsystems released JDK 1.0 in the first half of 1996. A significant part of this new language was a package called java.awt, which contains the classes for the AWT. In its early days, Java was associated very closely with the Internet and, thanks to its incorporation in Netscape’s popular Web browser, the sight of cool applets written in Java became commonplace. A Web site without a Java applet of some kind soon became hard to find. While dedicated surfers searched for the next exciting applet, programmers were busy trying to meet user expectations using the facilities of the AWT—for it is the AWT that provides the user interface that, when viewed through a Web browser, becomes a Java applet. Most of the original Java applets were of a similar, rather simple, type: moving images, dancing text, showers of pixels and just about anything that caught the eye. The aim was usually just to liven up an otherwise static Web page and attract as many callers as possible, in the hope that at least some of them might look at and, better still, buy the product or service that the Web site’s owner was offering. Creating such simple applets did not really place much of a demand on the AWT. Most of the work revolved around loading and displaying sequences of images or animating some simple text. More sophisticated applets allowed user interaction using the mouse or the keyboard but, on the whole, the level of functionality required from the AWT by these applets was very low. Alongside the applet developers, others were trying to use Java to develop weight- ier applications, such as office productivity tools and database client interfaces. While the applet developer was very happy with his new-found freedom of expression and got just about all he needed from the AWT, his colleagues were typically less impressed. For serious development work, AWT 1.0 simply did not stand up to scru- tiny. For one thing, it was slow. While this is not such an issue on the Internet, it assumes great importance to a user accustomed to applications written in C or C++ that usually (but with some notable exceptions) don’t require you to wait a noticeable amount of time for some- What Are the Java Foundation Classes? 7 thing to happen after pressing a button. For another, the AWT simply wasn’t robust enough—the implementation, particularly of the Windows version, was buggy and required developers to spend inordinate amounts of time looking for solutions to problems that weren’t in their own code and having to produce work-arounds to patch up their applications and make them usable. Worst of all, though, the AWT did- n’t provide much variety in its range of user interface elements. User interfaces have come a long way since the days of DOS. These days, even Unix has a windowing interface and only programmers and (some) system adminis- trators still toil away at the shell prompt. Over the years, beginning with the introduction of Windows 3.0 and continuing up to the present day, users have become accustomed to interacting with applications using a mouse and a collection of famil- iar controls such as buttons, scroll bars, text fields and so on. Each release of Windows or the Motif toolkit brought new elements to the user’s attention, most of which were quickly accepted and became indispensable. Unfortunately, AWT 1.0 was not particularly sophisticated in its supply of visual controls, so developers who wanted to make their Java spreadsheet or word proces- sor resemble existing products had to start virtually from scratch and write their own components. Inevitably, this was a long and tiresome process, repeated in many companies around the world. The end result, of course, was that there never were that many serious Java applications developed with AWT 1.0 that made it to the marketplace, even in Beta form. By the time the development community had come to terms with creating their own components, JavaSoft had released JDK 1.1 and, along with it, version 1.1 of the AWT. By comparison to its predecessor, AWT 1.1 was a great improvement. The Windows version was completely rewritten and was made much faster and more robust. Better integration with the user’s desktop was provided and, for the first time, a Java programmer could give an application access to a printer without needing to write platform-dependent native code. The programming model was improved, too, with a better mechanism for handling events from the user interface and, with the introduction of the JavaBeans specification and its incorporation in JDK 1.1, it became possible for developers to create components that could be taken and reused elsewhere more easily and could even be incorporated into graphical application builder tools such as Microsoft Visual Basic or Borland JBuilder. But still, there remained the issue of user interface sophistication. Notwithstanding the breadth of JDK 1.1 and the immense improvement in the quality of the AWT, only two new components (a scrolling window and a pop-up menu) were added. Developers still had to produce most of their own user interface controls. Enter Netscape Meanwhile developers at Netscape had begun development of a set of improved user controls that were eventually released under the banner of the Internet Foundation 8 Chapter 1 Introduction to the Java Foundation Classes Classes (IFC). Implemented on top of AWT 1.0, the IFC components were a more complete set than their predecessors and included some nice features such as dialogs to allow a user to choose colors, files and fonts visually, buttons with images, sliders, bitmaps (images that load synchronously), support for animation sequences and an improved application framework that supported the nesting of parts of an application’s interface inside other parts, with drawn boundaries to emphasize the nesting and grouping of components. As well as providing improved functionality, the IFC components were different from AWT in another way. Whereas the AWT components are implemented partly in Java and partly as a platform-dependent native library, the IFC components are written entirely in Java. As a result, the IFC is immediately portable to any platform that supports Java and takes with it its look-and-feel, unlike the AWT, which adopts the appearance of its host platform. The Swing Set:A Joint Effort In the early part of 1997, developers from Netscape and JavaSoft began cooperating on a project that was dubbed Swing.

Load more