Learning Java, 2nd Edition | Learning Java, Second Edition



	Table of Contents
	Index
	Reviews
	Examples
	CD-ROM
	Reader Reviews
	Errata

Learning Java , 2nd Edition
By Jonathan Knudsen, Pat Niemeyer

Publisher	: O'Reilly
Pub Date	: July 2002
ISBN	: 0-596-00285-8
Pages	: 700

This new edition of Learning Java has been expanded and updated for Java 2 Standard Edition SDK 1.4. It comprehensively addresses important topics such as web applications, servlets, and XML that are increasingly driving enterprise applications. This edition provides full coverage of all Java 1.4 language features including assertions and exception chaining as well as new APIs such as regular expressions and NIO, the new I/O package. New Swing features and components are described along with updated coverage of the JavaBeans component architecture using the open source NetBeans IDE the latest information about Applets and the Java Plug-in for all major web browsers.

777

Preface

New Developments

Audience

Using This Book

Online Resources

Conventions Used in This Book

How to Contact Us

Acknowledgments

Chapter 1. Yet Another Language?

Section 1.1. Enter Java

Section 1.2. A Virtual Machine

Section 1.3. Java Compared with Other Languages

Section 1.4. Safety of Design

Section 1.5. Safety of Implementation

Section 1.6. Application and User-Level Security

Section 1.7. Java and the Web

Section 1.8. Java as a General Application Language

Section 1.9. A Java Road Map

Chapter 2. A First Application

Section 2.1. HelloJava

Section 2.2. HelloJava2: The Sequel

Section 2.3. HelloJava3: The Button Strikes!

Section 2.4. HelloJava4: Netscape's Revenge

Chapter 3. Tools of the Trade

Section 3.1. The Java Interpreter

Section 3.2. The Classpath

Section 3.3. Policy Files

Section 3.4. The Java Compiler

Section 3.5. Java Archive (JAR) Files

Chapter 4. The Java Language

Section 4.1. Text Encoding

Section 4.2. Comments

Section 4.3. Types

Section 4.4. Statements and Expressions

Section 4.5. Exceptions

Section 4.6. Assertions

Section 4.7. Arrays

Chapter 5. Objects in Java

Section 5.1. Classes

Section 5.2. Methods

Section 5.3. Object Creation

Section 5.4. Object Destruction

Chapter 6. Relationships Among Classes

Section 6.1. Subclassing and Inheritance

Section 6.2. Interfaces

Section 6.3. Packages and Compilation Units

Section 6.4. Visibility of Variables and Methods

Section 6.5. Arrays and the Class Hierarchy

Section 6.6. Inner Classes

Chapter 7. Working with Objects and Classes

Section 7.1. The Object Class

Section 7.2. The Class Class

Section 7.3. Reflection

Chapter 8. Threads

Section 8.1. Introducing Threads

Section 8.2. Threading an Applet

Section 8.3. Synchronization

Section 8.4. Scheduling and Priority

Section 8.5. Thread Groups

Section 8.6. Thread Performance

Chapter 9. Working with Text

Section 9.1. Other Text-Related APIs

Section 9.2. Strings

Section 9.3. Parsing and Formatting Text

Section 9.4. Internationalization

Section 9.5. The java.text Package

Section 9.6. Regular Expressions

Chapter 10. Core Utilities

Section 10.1. Math Utilities

Section 10.2. Dates

Section 10.3. Timers

Section 10.4. Collections

Section 10.5. Properties

Section 10.6. The Preferences API

Section 10.7. The Logging API

Section 10.8. Observers and Observables

Chapter 11. Input/Output Facilities

Section 11.1. Streams

Section 11.2. Files

Section 11.3. Serialization

Section 11.4. Data Compression

Section 11.5. The NIO Package

Chapter 12. Network Programming

Section 12.1. Sockets

Section 12.2. Datagram Sockets

Section 12.3. Simple Serialized Object Protocols

Section 12.4. Remote Method Invocation

Section 12.5. Scaleable I/O with NIO

Chapter 13. Programming for the Web

Section 13.1. Uniform Resource Locators (URLs)

Section 13.2. The URL Class

Section 13.3. Handlers in Practice

Chapter 14. Servlets and Web Applications

Section 14.1. Servlets: Powerful Tools

Section 14.2. Web Applications

Section 14.3. The Servlet Life Cycle

Section 14.4. Web Servlets

Section 14.5. The HelloClient Servlet

Section 14.6. The Servlet Response

Section 14.7. Servlet Parameters

Section 14.8. The ShowParameters Servlet

Section 14.9. User Session Management

Section 14.10. The ServletContext API

Section 14.11. WAR Files and Deployment

Section 14.12. Reloading WebApps

Section 14.13. Error and Index Pages

Section 14.14. Security and Authentication

Section 14.15. Servlet Filters

Section 14.16. Building WAR Files with Ant

Chapter 15. Swing

Section 15.1. Components

Section 15.2. Containers

Section 15.3. Events

Section 15.4. Event Summary

Section 15.5. The AWT Robot!

Section 15.6. Multithreading in Swing

Chapter 16. Using Swing Components

Section 16.1. Buttons and Labels

Section 16.2. Checkboxes and Radio Buttons

Section 16.3. Lists and Combo Boxes

Section 16.4. The Spinner

Section 16.5. Borders

Section 16.6. Menus

Section 16.7. The PopupMenu Class

Section 16.8. The JScrollPane Class

Section 16.9. The JSplitPane Class

Section 16.10. The JTabbedPane Class

Section 16.11. Scrollbars and Sliders

Section 16.12. Dialogs

Chapter 17. More Swing Components

Section 17.1. Text Components

Section 17.2. Focus Navigation

Section 17.3. Trees

Section 17.4. Tables

Section 17.5. Desktops

Section 17.6. Pluggable Look-and-Feel

Section 17.7. Creating Custom Components

Chapter 18. Layout Managers

Section 18.1. FlowLayout

Section 18.2. GridLayout

Section 18.3. BorderLayout

Section 18.4. BoxLayout

Section 18.5. CardLayout

Section 18.6. GridBagLayout

Section 18.7. Nonstandard Layout Managers

Section 18.8. Absolute Positioning

Section 18.9. SpringLayout

Chapter 19. Drawing with the 2D API

Section 19.1. The Big Picture

Section 19.2. The Rendering Pipeline

Section 19.3. A Quick Tour of Java 2D

Section 19.4. Filling Shapes

Section 19.5. Stroking Shape Outlines

Section 19.6. Using Fonts

Section 19.7. Displaying Images

Section 19.8. Drawing Techniques

Section 19.9. Printing

Chapter 20. Working with Images and Other Media

Section 20.1. ImageObserver

Section 20.2. MediaTracker

Section 20.3. Producing Image Data

Section 20.4. Filtering Image Data

Section 20.5. Simple Audio

Section 20.6. Java Media Framework

Chapter 21. JavaBeans

Section 21.1. What's a Bean?

Section 21.2. The NetBeans IDE

Section 21.3. Properties and Customizers

Section 21.4. Event Hookups and Adapters

Section 21.5. Binding Properties

Section 21.6. Building Beans

Section 21.7. Limitations of Visual Design

Section 21.8. Serialization Versus Code Generation

Section 21.9. Customizing with BeanInfo

Section 21.10. Hand-Coding with Beans

Section 21.11. BeanContext and BeanContextServices

Section 21.12. The Java Activation Framework

Section 21.13. Enterprise JavaBeans

Chapter 22. Applets

Section 22.1. The Politics of Applets

Section 22.2. The JApplet Class

Section 22.3. The <APPLET> Tag

Section 22.4. Using the Java Plug-in

Section 22.5. Java Web Start

Section 22.6. Using Digital Signatures

Chapter 23. XML

Section 23.1. A Bit of Background

Section 23.2. XML Basics

Section 23.3. SAX

Section 23.4. DOM

Section 23.5. Validating Documents

Section 23.6. XSL/XSLT

Section 23.7. Web Services

Appendix A. Content and Protocol Handlers

Section A.1. Writing a Content Handler

Section A.2. Writing a Protocol Handler

Appendix B. BeanShell: Simple Java Scripting

Section B.1. Running BeanShell

Section B.2. Java Statements and Expressions

Section B.3. BeanShell Commands

Section B.4. Scripted Methods and Objects

Section B.5. Changing the Classpath

Section B.6. Learning More ...

Glossary

Colophon

Index

Printed in the United States of America.

Published by O'Reilly & Associates, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.

O'Reilly & Associates books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://safari.oreilly.com). For more information contact our corporate/institutional sales department: 800-998-9938 or corporate@oreilly.com.

Nutshell Handbook, the Nutshell Handbook logo, and the O'Reilly logo are registered trademarks of O'Reilly & Associates, Inc. Java and all Java-based trademarks and logos are trademarks or registered trademarks of Sun Microsystems, Inc., in the United States and other countries. O'Reilly & Associates, Inc., is independent of Sun Microsystems.

Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and O'Reilly & Associates, Inc. was aware of a trademark claim, the designations have been printed in caps or initial caps. The association between a Bengal tigress and cubs and the topic of learning Java is a trademark of O'Reilly & Associates, Inc.

While every precaution has been taken in the preparation of this book, the publisher and the authors assume no responsibility for errors or omissions, or for damages resulting from the use of the information contained herein.

Preface

This book is about the Java language and programming environment. Whether you are a software developer or just someone who's been active on the Internet in the past few years, you've undoubtedly heard a lot about Java. Its introduction was one of the most exciting developments in the history of the Internet. Java became the darling of the Internet programming community as soon as the alpha version was released in 1995. Immediately, thousands of people were writing Java applets to add to their web pages. Since then Java has grown up and traveled far from its browser-based roots. Java is now, arguably, the most popular programming language in the world, used by millions. In recent years Java has surpassed languages such as C++ and Visual Basic in terms of developer demand and become the de facto language for new development especially for web-based applications and services. Most universities are now using Java in their introductory courses, alongside the other important modern languages. Perhaps you are using this text in one of your classes right now!

What, then, is Java? Java is a new kind of programming language that was developed by Sun Microsystems to work on myriads of computing devices and to thrive in networked applications. It's widely used to create interactive web pages and web services. However, we have still seen only the start. The Java language and environment are rich enough to support new kinds of applications, such as dynamically extensible web browsers and mobile agents. Entirely new kinds of computer platforms have been and are being developed around Java; these include handheld devices and network computers that download all their software dynamically over the network. In the coming years, we'll see even more of what Java can do. Fancy web pages are fun and interesting, but they certainly aren't the end of the story. The success of Java is changing the way we think about computing in fundamental ways.

This book gives you a thorough grounding in Java fundamentals. Learning Java, Second Edition, attempts to live up to its name by mapping out the Java language, its class libraries, programming techniques, and idioms. We'll dig deep into interesting areas and at least scratch the surface of the rest. Other titles from O'Reilly & Associates pick up where we leave off and provide more comprehensive information on specific areas and applications of Java.

Whenever possible, we provide compelling, realistic and examples and avoid merely cataloging features. The examples are simple but hint at what can be done. We won't be developing the next great "killer app" in these pages, but we hope to give you a starting point for many hours of experimentation and inspired tinkering that will lead you to learn more on your own.

New Developments

This book, Learning Java, is actually the fourth edition reworked and retitled of our original popular Exploring Java. With each edition we've taken great care not only to add new material covering additional features, but to thoroughly revise and update the existing content to synthesize the coverage and add years of real world perspective and experience to these pages.

One noticeable change in recent editions is that we've deemphasized the use of applets, reflecting their somewhat static role over the past couple of years in creating interactive web pages. And in this edition we've greatly expanded our coverage of web applications and services, which are now mature technologies. We've also included a chapter on working with XML and XSL, which are important new technologies.

We cover the most interesting features of Sun's newest release of Java, officially called Java 2 Standard Edition SDK Version 1.4 . (In the old days, it would have been called JDK for Java Development Kit; Sun now uses the term SDK for Software Development Kit.) Sun coined the term "Java 2" to cover the major new features introduced in Java Version 1.2. When it's necessary to mention versions, we'll simply refer to them as Java 1.x.

New features in Java 1.4 include important improvements for servlets and web applications, regular expressions, Swing enhancements, new language features such as assertions and chained exceptions, logging and preferences APIs and a completely new I/O facility.

Another important change in recent Java history (Version 1.2) was the ascendancy of Java Swing as the main API for graphical user interface programming. All the material in this book relating to AWT, Java's original GUI programming interface, has been recast and updated in terms of the Swing facilities.

New in This Edition

This edition of the book has been significantly reworked to be as complete and up to date as possible. New topics in this edition include:

Language assertions and exception chaining (Chapter 4)
Regular expressions (Chapter 9)
The new preferences and logging APIs (Chapter 10)
The NIO package for scaleable I/O (Chapter 11 and Chapter 12)
Full coverage of the servlet and web applications API (Chapter 14)
Swing updates including formatted text and the new focus system (Chapters Chapter 15 through Chapter 17)
JavaBeans examples using the NetBeans IDE (Chapter 21)
Information on the Java Plug-in and applet signing (Chapter 22)
Full coverage of XML including SAX, DOM, DTDs, XSL/XSLT, and the new JavaBeans XMLEncoder (Chapter 23)

Audience

This book is for computer professionals, students, technical people, and Finnish hackers. It's for everyone who has a need for hands-on experience with the Java language with an eye toward building real applications. This book could also be considered a crash course in object-oriented programming; as you learn about Java, you'll also learn a powerful and practical approach to object-oriented software development.

Superficially, Java looks like C or C++, so you'll have a head start in using this book if you have some experience with one of these languages. If you do not however, don't worry. Don't make too much of the syntactic similarities between Java and C or C++. In many respects, Java acts like more dynamic languages such as Smalltalk and Lisp. Knowledge of another object-oriented programming language should certainly help, although you may have to change some ideas and unlearn a few habits. Java is considerably simpler than languages like C++ and Smalltalk. If you learn well from good, concise examples and personal experimentation, we think you'll like this book.

Although we encourage you to take a broad view, you would have every right to be disappointed if we ignored the Web. A substantial part of this book does discuss Java in the context of web applications, so you should be familiar with the basic ideas behind web browsers, servers, and documents.

Using This Book

This book is organized roughly as follows:

Chapter 1 and Chapter 2 provide a basic introduction to Java concepts and a tutorial to give you a jump start on Java programming.
Chapter 3 discusses tools for developing with Java (the compiler, the interpreter, and the JAR file package). It also covers important concepts such as embedding Java code in HTML support and object signing.
Chapter 4 through Chapter 8 describe the Java language itself. Chapter 8 covers the language's thread facilities, which should be of particular interest to advanced programmers.
Chapter 9 covers basic string utilities and the powerful Regular Expressions API.
Chapter 10 and Chapter 11 cover much of the core API. Chapter 10 describes basic utilities, and Chapter 11 covers I/O facilities.
Chapter 12 and Chapter 13 cover Java networking including sockets and NIO, URLs, and remote method invocation (RMI).
Chapter 14 covers web applications using servlets, servlet filters, and WAR files.
Chapter 15 through Chapter 20 cover the Abstract Window Toolkit (AWT) and Swing, which provide graphical user interface (GUI) and image support.
Chapter 21 covers the JavaBeans component architecture.
Chapter 22 covers applets, the area in which Java saw its initial success.
Chapter 23 covers the Java APIs for working with XML and XSLT.

If you're like us, you don't read books from front to back. If you're really like us, you usually don't read the Preface at all. However, on the off chance that you will see this in time, here are a few suggestions:

If you are an experienced programmer who has to learn Java in the next five minutes, you are probably looking for the examples. You might want to start by glancing at the tutorial in Chapter 2. If that doesn't float your boat, you should at least look at the information in Chapter 3, which tells how to use the compiler and interpreter, and gives the basics of a standalone Java application. This should get you started.
Chapter 12 through Chapter 14 are essential if you are interested in writing advanced networked or web-based applications. This is one of the more interesting and important parts of Java.
Chapter 15 though Chapter 21 discuss Java's graphics features and component architecture. You should read this if you are interested in writing graphical Java applications or applets.
Chapter 22 covers the Applet API, including the Java Plug-in for guaranteed browser compatibility and signed applets for advanced applications.
Chapter 23 covers the Java APIs for working with XML, including SAX, DOM, DTDs, and using XSL to render output for the Web. XML technology is becoming key to cross-platform development.

On the CD-ROM

The accompanying CD-ROM provides all you need to start working with Java immediately (view CD content online at http://examples.oreilly.com/learnjava2/CD-ROM/). Open source software on the CD-ROM includes:

Java 2 Standard Edition SDK (Version 1.4.0)
NetBeans (Version 3.3.1), a visual IDE for working with JavaBeans
Ant (Version 1.4.1), a Java servlet engine from the Jakarta Project
Tomcat (Version 4.0.3), a Java servlet engine from the Jakarta Project
BeanShell (Version 1.2), a simple Java scripting language

Online Resources

There are many online sources for information about Java. Sun Microsystems's official web site for Java topics is http://java.sun.com; look here for the latest news, updates, and Java releases. This is where you'll find the Java SDK, which includes the compiler, the interpreter, and other tools (the SDK is also on the CD-ROM that comes with this book; view CD content online at http://examples.oreilly.com/learnjava2/CD-ROM/).

You should also visit O'Reilly & Associates' Java site at http://java.oreilly.com. There you'll find information about other O'Reilly Java books, and a pointer to the home page for Learning Java, http://www.oreilly.com/catalog/learnjava2/, where you'll find the source code examples for this book.

The comp.lang.java newsgroup can be a good source of information and announcements, and a place to ask intelligent questions.

Conventions Used in This Book

The font conventions used in this book are quite simple.

Italic is used for:

Unix pathnames, filenames, and program names
Internet addresses, such as domain names and URLs
New terms where they are defined
GUI buttons and menus, and threads
Program names, compilers, interpreters, utilities, and commands

Constant width is used for:

Anything that might appear in a Java program, including method names, variable names, and class names
Command lines and options that should be typed verbatim on the screen
Tags that might appear in an HTML or XML document
Keywords, objects, and environment variables

Constant width bold is used for:

Text that is typed by the user in code examples

Constant width italic is used for:

Replaceable items in code

This icon designates a note, which is an important aside to the nearby text.

This icon designates a warning relating to the nearby text.

In the main body of text, we always use a pair of empty parentheses after a method name to distinguish methods from variables and other creatures.

In the Java source listings, we follow the coding conventions most frequently used in the Java community. Class names begin with capital letters; variable and method names begin with lowercase. All the letters in the names of constants are capitalized. We don't use underscores to separate words in a long name; following common practice, we capitalize individual words (after the first) and run the words together. For example: thisIsAVariable, thisIsAMethod(), ThisIsAClass, and THISISACONSTANT. Also, note that we differentiate between static and nonstatic methods when we refer to them. Unlike some books, we never write Foo.bar() to mean the bar() method of Foo unless bar() is actually static.

How to Contact Us

Please address comments and questions concerning this book to the publisher:

O'Reilly & Associates, Inc.

1005 Gravenstein Highway North

Sebastopol, CA 95472

(800) 998-9938 (in the United States or Canada)

(707) 829-0515 (international or local)

(707) 829-0104 (fax)

We have a web page for this book, where we list errata, examples, or any additional information. You can access this page at:

http://www.oreilly.com/catalog/learnjava2

To comment or ask technical questions about this book, send email to:

bookquestions@oreilly.com

For more information about our books, conferences, Resource Centers, and the O'Reilly Network, see our web site at:

http://www.oreilly.com

Acknowledgments

Many people have contributed to putting this book together, both in its Exploring Java incarnation and in its current form as Learning Java. Foremost we would like to thank Tim O'Reilly for giving us the opportunity to write this book. Special thanks to Mike Loukides, the series editor, whose endless patience and experience got us through the difficult parts. Paula Ferguson and John Posner contributed their organizational and editing abilities to get the material into final form. We could not have asked for a more skillful or responsive team of people with whom to work.

Speaking of borrowings, the original version of the glossary came from David Flanagan's book, Java in a Nutshell. We also borrowed the class hierarchy diagrams from David's book. These diagrams were based on similar diagrams by Charles L. Perkins. His original diagrams are available at http://rendezvous.com/java/.

Thanks also to Marc Wallace and Steven Burkett for reading the original work in progress and for the support of our friends at Washington University. A big thanks to Deb Cameron who edited this edition of the book and kept me from getting too far behind schedule (thanks for all the hard work Deb!). Thanks to all those who reviewed or answered questions for the latest edition: Jim Elliott and Brian Cole for Swing, Jack Shirazi for NIO, Tim Boudreau for NetBeans, Ed Howland for XML, and Ian Darwin for regular expressions. (Check out Ian's O'Reilly Java Cookbook for more examples.) Thanks also to Ray O'Leary, Mario Aquino, and Mark Volkmann for their reviews. Finally, special thanks to Song Fang for putting up with me through all this work.