giáo trình Java By Example phần 1 ppsx

Java
By Example
Clayton Walnum
C O N T E N T S
Introduction
Who This Book Is For●
Hardware and Software Requirements●
Compiling the Programs in This Book●
A Word to the Wise●
On to the Wonderful World of Java●
Chapter 1 Java Overview
The Java Story●
Introducing Java●
Java Programs●
The Java Developer's Kit●
Where Is Java?●
Example: Installing HotJava●
Example: Installing the JDK●
Summary●
Review Questions●
Review Exercises●
o
Chapter 2 Running Java Applets
The Sample Java Applets
The Appletviewer Tool❍
Example: Running TicTacToe❍
The Animator Applet❍
The BarChart Applet❍
Other Demo Applets❍
●
Adding Applets to an HTML Document

Optional Attributes for Applets❍
Applet Parameters❍
Non-Java Browsers❍
Example: A Java-Powered Home Page❍
●
Summary●
Review Questions●
Review Exercises●
Chapter 3 Applets and the Internet
Local and Remote Applets
Local Applets❍
Remote Applets❍
●
Clients and Servers●
Security●
Example: Your Pages on the Web●
Summary●
Review Questions●
Review Exercises●
Chapter 4 Object-Oriented Programming Concepts
From Switches to Objects●
An Obvious, Yet Brilliant, Solution●
Object-Oriented Programming●
o
Encapsulation❍
Classes as Data Types❍
Inheritance❍
Polymorphism❍
Example: Encapsulation, Inheritance, and Polymorphism❍
Summary●

Review Questions●
Review Exercises●
Chapter 5 Constants and Variables
Constants●
Variables●
Naming Constants and Variables●
Example: Creating Your Own Identifiers●
Data Types
Integer Values❍
Floating-Point Values❍
Character Values❍
Boolean Values❍
●
Variable Scope
Example: Determining a Variable's Scope❍
●
Summary●
Review Questions●
Review Exercises●
Chapter 6 Simple Input and Output
Windows and Graphics●
Displaying Text in an Applet
Example: Creating and Running Applet1❍
How Applet1 Works❍
●
Getting Input from the User
How Applet2 Works❍
●
o
Example: Retrieving text from a TextField control❍

How Applet3 Works❍
Displaying Numerical Values●
Summary●
Review Questions●
Review Exercises●
Chapter 7 Math Operators
The Addition Operator
Example: Using the Addition Operator❍
Example: Multiple Additions❍
●
The Subtraction Operator
Example: Using the Subtraction Operator❍
Example: Multiple Subtractions Using Mixed Data Types❍
Example: Casting a Result to a Different Data Type❍
●
The Multiplication Operator
Example: Multiplication and Data Types❍
●
The Division Operator
Example: Integer Versus Floating-Point Division❍
●
The Modulo Operator●
The Increment Operator●
The Decrement Operator●
Example: Using Mathematical Calculations in an Applet
How Applet5 Works❍
●
The Order of Operations
Example: Order of Operations❍
Example: More Order of Operations❍

Example: Still More Order of Operations❍
Example: One Last Order of Operations❍
●
Summary●
Review Questions●
Review Exercises●
o
Chapter 8 Expressions
Types of Expressions●
Expressions Within Expressions●
Comparison Operators
Example: Using Comparison Operators❍
●
Logical Operators
Example: Using Logical Operators❍
Example: Using Multiple Logical Operators❍
Example: Combining Different Comparison and Logical Operators❍
●
Writing Logical Expressions●
Order of Operations●
Summary●
Review Questions●
Review Exercises●
Chapter 9 The if and switch Statements
Controlling Program Flow●
Program Flow and Branching●
The if statement
Example: The Form of an if Statement❍
Multiple if Statements❍
Multiple-Line if Statements❍

The else Clause❍
Example: Using the if Statement in a Program❍
●
The switch Statement
Example: Using the break Statement Correctly❍
Example: Using the switch Statement in a Program❍
●
Summary●
Review Questions●
Review Exercises●
o
Chapter 10 The while and do-while Loops
The while Loop
Example: Using a while Loop❍
Example: Using a while Loop in a Program❍
●
The do-while Loop
Example: Using a do-while Loop❍
Example: Using a do-while Loop in a Program❍
●
Summary●
Review Questions●
Review Exercises●
Chapter 11 The for Loop
Introducing the for Loop●
Example: Using a for Loop●
Example: Using a for Loop in a Program●
Changing the Increment Value●
Example: Looping with Different Increments●
Using Variables in Loops●

Example: Controlling for Loops with Variables●
Summary●
Review Questions●
Review Exercises●
Chapter 12 Functions
The Top-Down Approach to Programming●
Example: Using Functions as Subroutines●
Defining and Calling Functions●
Example: Using Functions to Return Values●
Example: Putting Functions to Work●
Summary●
Review Questions●
o
Review Exercises●
Chapter 13 Arrays
An Introduction to Arrays
Example: Creating an Array❍
Example: Using a Variable as a Subscript❍
●
Multidimensional Arrays
Example: Creating a Two-Dimensional Array❍
●
Example: Using Two-Dimensional Arrays in an Applet●
Summary●
Review Questions●
Review Exercises●
Chapter 14 Classes
Classes and Objects
Defining a Simple Class❍
Declaring Fields for a Class❍

Defining a Constructor❍
Example: Creating an Object by Calling a Constructor❍
Defining Methods❍
●
Example: Using Classes in Applets●
Understanding the Applet●
Using Inheritance
Creating a Subclass❍
Adding Fields and Methods to the Subclass❍
Example: Adding Fields and Methods❍
●
Example: Using a Subclass in a Program●
Overriding Methods of the Superclass●
The this Keyword●
Summary●
Review Questions●
Review Exercises●
o
Chapter 15 Writing a Simple Applet
The Simplest Java Applet●
The Five Stages of an Applet's Life Cycle●
Example: Overriding the Life Cycle Methods●
Summary●
Review Questions●
Review Exercises●
Chapter 16 Drawing Graphics
The Applet's Canvas●
Example: Using the Coordinate System●
Drawing Shapes●
Example: Drawing a Rectangle●

Example: Drawing Other Shapes●
Understanding the ShapeApplet Applet
Drawing Ovals❍
Drawing Arcs❍
Example: Drawing Arcs in an Applet❍
Drawing Polygons❍
●
Summary●
Review Questions●
Review Exercises●
Chapter 17 Graphical Text
Dealing with Graphical Text
Getting Font Attributes❍
Example: Displaying Font Information❍
Getting Font Metrics❍
Example: Displaying Font Metrics❍
●
Creating Fonts
Example: Creating a Font with Multiple Styles❍
●
o
Using the Font❍
Example: Displaying Different Sized Fonts❍
Summary●
Review Questions●
Review Exercises●
Chapter 18 Label and Button Controls
Labels
Example: Creating a Label❍
Methods of the Label Class❍

●
Buttons
Example: Adding a Button to an Applet❍
Handling Multiple-Button Events❍
Example: Handling Multiple Buttons in an Applet❍
●
Summary●
Review Questions●
Review Exercises●
Chapter 19 Checkbox and TextField Controls
Checkboxes
Example: Creating Nonexclusive Checkboxes❍
Checkbox Groups❍
Checkbox Methods❍
Example: Handling Checkboxes in an Applet❍
Responding to a Checkbox Event❍
Example: Handling Checkbox Events in an Applet❍
●
TextFields
TextField Methods❍
Example: Using Echo Characters❍
●
Summary●
Review Questions●
Review Exercises●
o
Chapter 20 Choice Menu, Text Area, and Scrolling
List Controls
Choice Menus
Example: Creating a Choice Menu❍

Choice Menu Methods❍
Example: Responding to Menu Events in an Applet❍
●
Scrolling Lists
Example: Creating a Single-Selection List❍
Example: Creating a Multiple-Selection List❍
Example: Creating a Scrolling List❍
Methods of the List Class❍
Example: Using a Scrolling List in an Applet❍
●
The TextArea Control
Example: Creating a TextArea Control❍
Methods of the TextArea Class❍
●
Summary●
Review Questions●
Review Exercises●
Chapter 21 Scrollbar and Canvas Controls
Scrollbars
Example: Creating a Scrollbar❍
Responding to a Scrollbar❍
Example: Using a Scrollbar in an Applet❍
Canvases❍
Example: Using a Canvas in an Applet❍
●
Summary●
Review Questions●
Review Exercises●
o
Chapter 22 Panels and Layout Managers

Panels
Example: Creating and Using Panels❍
●
Layout Managers●
The FlowLayout Manager
Example: Creating a FlowLayout Manager❍
●
The GridLayout Manager
Creating a GridLayout Manager❍
●
The BorderLayout Manager
Creating a BorderLayout Manager❍
●
The CardLayout Manager
The CardLayout Manager Methods❍
Example: Creating a CardLayout Manager❍
●
The GridBagLayout Manager
Creating and Setting the GridBagLayout Manager❍
Creating and Setting a GridBagConstraints Object❍
Example: Using a GridBagLayout Manager in an Applet❍
Understanding the GridBagApplet Applet❍
●
Summary●
Review Questions●
Review Exercises●
Chapter 23 Windows and Menu Bars
Displaying a Window
Example: Displaying a Window in an Applet❍
Example: Creating a Window Class❍

Example: Adding Components to a Window❍
●
Using Menu Bars
Creating and Setting a MenuBar Object❍
Adding Menus to a Menu Bar❍
Adding Menu Items to Menus❍
Example: Using a Menu Bar in a Frame Window❍
●
o
Summary●
Review Questions●
Review Exercises●
Chapter 24 Dialog Boxes
Using a Dialog Box
Creating the Dialog Box❍
Creating the Dialog Box's Layout❍
Displaying the Dialog Box❍
Removing the Dialog Box❍
Methods of the Dialog Class❍
Example: A Dialog Box for Text Input❍
●
Summary●
Review Questions●
Review Exercises●
Chapter 25 Mouse and Keyboard Events
The Event Object●
The Mouse
Handling Mouse Clicks❍
Example: Using Mouse Clicks in an Applet❍
Handling Mouse Movement❍

Example: Responding to Mouse Movement in an Applet❍
●
The Keyboard
Responding to Key Presses❍
Predefined Key Constants❍
Key Modifiers❍
Example: Using Key Presses in an Applet❍
●
Handling Events Directly
Example: Overriding handleEvent() in an Applet❍
●
Summary●
Review Questions●
o
Review Exercises●
Chapter 26 Configurable Applets
Types of Users●
Parameters and Applets
Example: Setting and Retrieving a Parameter's Value❍
Example: Using a Parameter in an Applet❍
●
Multiple Parameters
Example: Using Multiple Parameters in an Applet❍
●
Default Parameter Values
Example: Using Default Parameters in an Applet❍
●
Summary●
Review Questions●
Review Exercises●

Chapter 27 Images and Sounds
Image Types●
Loading and Displaying an Image
Example: Using the getDocumentBase() Method❍
Example: Using the getCodeBase() Method❍
Loading an Image❍
Displaying an Image❍
Example: Displaying an Image in an Applet❍
●
Playing a Sound
Example: Using the play() Method❍
Example: Playing a Sound in an Applet❍
Controlling Sounds❍
Example: Using an AudioClip in an Applet❍
●
Summary●
Review Questions●
Review Exercises●
o
Chapter 28 Communications
URL Objects
Example: Creating an URL Object❍
URL Exceptions❍
●
The Applet Context
Example: Using an AppletContext to Link to an URL❍
Example: Using an AppletContext in an Applet❍
●
Creating a "Favorite URLs" Applet●
Summary●

Review Questions●
Review Exercises●
Chapter 29 Packages and Interfaces
Packages
Creating Your Own Packages❍
Example: Creating a Simple Package❍
Example: Using the New Package❍
Example: Extending the Package❍
●
Interfaces
The Basic Interface❍
Example: Creating an Interface❍
Implementing an Interface❍
●
Summary●
Review Questions●
Review Exercises●
Chapter 30 Exceptions
Java's Exceptions●
Throwing an Exception●
Types of Exceptions●
Determining the Exceptions to Handle●
o
Example: Catching a Runtime Exception❍
Example: Handling Multiple Exceptions❍
Summary●
Review Questions●
Review Exercises●
Chapter 31 Threads
Two Kinds of Threads●

Converting a Class to a Thread
Declaring the Class as Implementing the Runnable Interface❍
Implementing the run() Method❍
Declaring a Thread Object❍
Creating and Starting the Thread Object❍
Stopping the Thread❍
Example: Using a Thread in an Applet❍
●
Deriving a Class from Thread
Example: Creating a Thread Class❍
Example: Using a Separate Thread in an Applet❍
●
Synchronizing Multiple Threads
Example: Using a Synchronized Method❍
Understanding ThreadApplet3❍
●
Summary●
Review Questions●
Review Exercises●
Chapter 32 Writing Java Applications
About Java Applications●
The Simplest Java Application
Example: Building an Application❍
Example: Getting an Application's Arguments❍
●
Windowed Applications
Example: Changing an Applet to an Application❍
●
o
Understanding the FaceApp Application❍

Summary●
Review Questions●
Review Exercises●
Chapter 33 Development Tools Overview
The Tools●
Using Appletviewer
Example: Loading More Than One Applet at a Time❍
Running the Debugger from Appletviewer❍
●
Using HotJava●
Using Java's Documentation Creator
Javadoc Tags❍
Example: Using Doc Tags❍
Example: Documenting an Applet❍
Javadoc Options❍
●
Using the Disassembler●
Using the C Header Generator●
Using the Debugger●
Summary●
Review Questions●
Review Exercises●
Chapter 34 Using the Compiler
What the Compiler Does●
Running the Compiler
Setting the Class Path❍
Specifying the Target Directory❍
Example: Setting the Target Directory❍
Creating Debugging Tables❍
Example: Adding Debugging Tables to an Applet❍

Suppressing Warnings❍
●
o
Optimizing a Program❍
Switching On Verbose Output❍
Summary●
Review Questions●
Review Exercises●
Chapter 35 Using the Interpreter
What the Interpreter Does●
Running the Interpreter
Keeping Files Up to Date❍
Setting the Class Path❍
Switching On Verbose Output❍
Example: Running an Application with Verbose Output❍
Getting Help❍
●
Summary●
Review Questions●
Review Exercises●
Chapter 36 The Java Class Libraries
The Packages●
The java.lang Package
Data-Type Wrappers❍
Example: Using the Data-Type Wrappers❍
The System Class❍
Example: Getting System Properties❍
The Math Class❍
The String Class❍
Example: Using the String Class❍

●
The io Package
Example: Reading a File❍
●
The awt Package●
Summary●
o
Review Questions●
Review Exercises●
Appendix A Answers to Review Questions
Chapter 1●
Chapter 2●
Chapter 3●
Chapter 4●
Chapter 5●
Chapter 6●
Chapter 7●
Chapter 8●
Chapter 9●
Chapter 10●
Chapter 11●
Chapter 12●
Chapter 13●
Chapter 14●
Chapter 15●
Chapter 16●
Chapter 17●
Chapter 18●
Chapter 19●
Chapter 20●

Chapter 21●
Chapter 22●
Chapter 23●
Chapter 24●
Chapter 25●
Chapter 26●
Chapter 27●
Chapter 28●
Chapter 29●
o
Chapter 30●
Chapter 31●
Chapter 32●
Chapter 33●
Chapter 34●
Chapter 35●
Chapter 36●
Appendix B Glossary
Appendix C IDEs and Tools
IDEs
Diva❍
Java+❍
JavaMaker❍
●
Tools
AppletGen❍
VbToJava❍
PortaFilter❍
●
Summary●

Credits
Java By Example
Copyright© 1996 by Que® Corporation
All rights reserved. Printed in the United States of America. No part of this book may be used or
reproduced in any form or by any means, or stored in a database or retrieval system, without prior written
permission of the publisher except in the case of brief quotations embodied in critical articles and
reviews. Making copies of any part of this book for any purpose other than your own personal use is a
violation of United States copyright laws. For information, address Que Corporation, 201 W. 103rd
Street, Indianapolis, IN 46290. You may reach Que's direct sales line by calling 1-800-428-5331.
ISBN: 0-7897-0814-0
o
This book is sold as is, without warranty of any kind, either express or implied, respecting the contents of
this book, including but not limited to implied warranties for the book's quality, performance,
merchantability, or fitness for any particular purpose. Neither Que Corporation nor its dealers or
distributors shall be liable to the purchaser or any other person or entity with respect to any liability, loss,
or damage caused or alleged to have been caused directly or indirectly by this book.
All terms mentioned in this book that are known to be trademarks or service marks have been
appropriately capitalized. Que cannot attest to the accuracy of this information. Use of a term in this
book should not be regarded as affecting the validity of any trademark or service mark.
HTML conversion by :
M/s. LeafWriters (India) Pvt. Ltd.
Website :
e-mail :
President and Publisher : Roland Elgey
Associate Publisher : Joseph B. Wikert
Director of Marketing : Lynn E. Zingraf
Editorial Services
Director
Elizabeth Keaffaber Managing Editor Sandy Doell
Title Manager Bryan Gambrel Acquisitions

Editor
Fred Stone
Product Director Ben Milstead Production Editor Mitzi Foster
Gianakos
Editors Anne Owen,
Joe Williams
Assistant Product
Marketing
Manager
Kim Margolius
Technical Editors David Medinets Acquisitions
Coordinator
Jane Brownlow
Operations
Coordinator
Patty Brooks Editorial Assistant Andrea Duvall
Book Designer Kim Scott Cover Designer Ruth Harvey
Production Team Steve Adams, Marcia Brizendine, Jason Carr, Jenny Earhart,
Joan Evan, Jessica Ford, Trey Frank, Amy Gornik, Jason
Hand, Daniel Harris, Damon Jordan, Daryl Kessler, Clint
Lahnen, Bob LaRoche, Kaylene Riemen, Laura Robbins,
Bobbi Satterfield, Kelly Warner, Jeff Yesh, Jody York
Indexer John Hulse
o
About the Author
Clayton Walnum, who has a degree in computer science, has been writing about computers for almost
15 years and has published hundreds of articles in major computer publications. He is also the author of
over 25 books, which cover such diverse topics as programming, computer gaming, and application
programs. His most recent book is Windows 95 Game SDK Strategy Guide, also published by Que. His
other titles include the award-winning Building Windows 95 Applications with Visual Basic (Que), 3-D

Graphics Programming with OpenGL (Que), Borland C++ 4.x Tips, Tricks, and Traps (Que), Turbo
C++ for Rookies (Que), Dungeons of Discovery (Que), PC Picasso: A Child's Computer Drawing Kit
(Sams), Powermonger: The Official Strategy Guide (Prima), DataMania: A Child's Computer Organizer
(Alpha Kids), Adventures in Artificial Life (Que), and C-manship Complete (Taylor Ridge Books). Mr.
Walnum lives in Connecticut with his wife Lynn and their four children, Christopher, Justin, Stephen,
and Caitlynn.
Acknowledgments
I would like to thank the following people for their contribution to this book: Joe Wikert for his
confidence in my writing; Fred Slone for keeping everything running smoothly; Mitzi Gianakos, Anne
Owen, and Joe Williams for keeping my abuse of the English language to a minimum; David Medinets
for checking the facts; and all the other fine folks at Que. And, as always, thanks to my family-Lynn,
Christopher, Justin, Stephen, and Caitlynn.
We'd Like to Hear from You!
As part of our continuing effort to produce books of the highest possible quality, Que would like to hear
your comments. To stay competitive, we really want you, as a computer book reader and user, to let us
know what you like or dislike most about this book or other Que products.
You can mail comments, ideas, or suggestions for improving future editions to the address below, or
send us a fax at (317) 581-4663. Our staff and authors are available for questions and comments through
our Internet site at and Macmillan Computer Publishing also has a
forum on CompuServe (type GO QUEBOOKS at any prompt).
In addition to exploring our forum, please feel free to contact me personally to discuss your opinions of
this book: I'm on the Internet, and 102121,1324 on CompuServe.
Thanks in advance-your comments will help us to continue publishing the best books available on
computer topics in today's market.
Ben Milstead
Product Director
Que Corporation
201 W. 103rd Street
Indianapolis, Indiana 46290
o

USA
Introduction
The Internet is growing by leaps and bounds. It won't be too long before you'll be able to contact just
about anyone online, not only your friends and acquaintances, but also every major company in the
country. This incredible growth is the pathway to opportunity. Everybody who's anybody in the world of
telecommunications is looking for ways to enhance the Internet's online experience. One company that
has scored a big hit on the Internet is Sun Microsystems, who recently released an unusual programming
language called Java. Once people got their hands on Java, the Internet was guaranteed to never be the
same again.
What's so special about Java? Java enables programmers to create something called applets. Applets are
special computer programs that can be included as an element of a Web page. When the user views a
Web page containing one of these applets, the machine he's connected to automatically sends the applet
to the user and the user's own Java-compatible browser runs the applet. Because applets are transferred in
a non-machine-specific form, they can run on any machine that has a Java interpreter.
Using Java, you can do everything from adding simple animation to your Web pages to writing
sophisticated computer programs that your Web page's users can use online. Applets that have already
been released include games, spreadsheets, graphing programs, animation controllers, simulators, and
much, much more. Java is so intriguing and so successful that even major players in the industry,
including Netscape and Microsoft, have jumped aboard, providing Java-compatible software for the
Internet.
In this book, you'll learn not only how Java applets work on the Internet, but also how to include Java
applets in your Web pages. More importantly, you'll learn step-by-step how to write your own applets.
You can write these applets for your own personal use, or write them for general release on the Internet.
Imagine the thrill of seeing one of your own Java creations being used on Web pages all over the world!
Who This Book Is For
This book is the perfect starting point for anyone wanting to learn from scratch about Java. Although it's
helpful to have previous programming experience (especially with C or C++), this book includes a
complete tutorial on the Java language and how to build applets with it. The Java tools, such as the
compiler and interpreter, that you'll need to create your own applets are described in detail. Moreover,
you'll learn the Java language starting from the very basics and working your way toward writing

full-featured applets and applications.
Although this book is suitable for programming novices, more experienced programmers will find a great
deal of interest here, as well. If you're already familiar with languages such as C and C++, you'll be able
to skim over the Java language introduction and dive right into the business of creating applets. Although
the Java language is very much like C++, the way it's used is unique. Up until Java, you've never seen
anything quite like applets.
o
To summarize, this book is for both novice and intermediate programmers. Novice programmers will get
a gentle introduction to the Java language, whereas more experienced programmers can concentrate on
getting the most from the language by quickly learning how to build powerful applets for the Internet.
Even expert programmers may find this book to be a useful introduction to the world of Java.
Hardware and Software Requirements
The Java language is currently supported on Windows 95, Windows NT, Sun Solaris, Macintosh, and
UNIX machines. Most of this book's content is applicable to any type of computer that can run the Java
Developers Kit. However, because Windows 95 will undoubtedly be the operating system under which
the greatest majority of Java applets are created, the programs and examples in this book were written for
the Windows 95 version of Java. Still, as long as you're familiar with your computer's operating system,
you should have little difficulty following the examples in this book no matter what machine you use.
The minimum system requirements for Windows 95 or NT users are as follows:
An IBM-compatible 80486 with at least 8M of memory●
Windows 95 or Windows NT●
A hard drive●
A CD-ROM drive●
A Microsoft-compatible mouse●
256-color graphics●
A Windows-compatible sound card*●
* If you don't care about hearing sound files with Java's applets, you don't need a sound card.
The CD-ROM included with this book runs on Windows machines and includes the Windows versions
of the Java Developers Kit and the HotJava Web browser. Users of other systems can get a copy of the
Java Developers Kit for their machine from Sun Microsystems' Web site at .

Compiling the Programs in This Book
As you work through the examples in this book, you'll learn to install the Java Developers Kit and to
compile the example programs that are presented in each chapter. In general, though, you can compile
the programs in this book by following the procedures given here.
First, you must have the Java Development Kit installed on your system, using the default root directory
of C:\JAVA. It would also be useful to have a copy of Netscape Navigator 2.0 installed. You can get a
copy of this Java-compatible browser from Netscape's Web site at .
After installing the Java Development Kit, you must include the kit's path in your system's PATH
statement. To do this, load your system files with SYSEDIT.EXE (you can find SYSEDIT.EXE in your
WINDOWS\SYSTEM directory). When you start SYSEDIT, go to the AUTOEXEC.BAT window and
find the PATH statement. At the end of the PATH statement, add a semicolon followed by the path
C:\JAVA\BIN. Then, save the changes and restart your machine so the changes take effect. Adding the
o
path to your PATH statement ensures that the system can find Java's tools.
Finally, you should create a directory called C:\CLASSES in which you will place the Java files you
create throughout this book. To compile and run an applet's Java source-code file, follow these steps:
Select the Start/Programs/MS-DOS Prompt command from the Start menu. A DOS window
appears.
1.
Change to the C:\CLASSES directory by typing cd c:\classes at the DOS prompt.2.
Type javac filename.java, where filename.java is the name of the Java source-code
file you want to compile. After compilation is complete, you should have a file called
filename.class in the directory, where filename is the same program name you used for the
.java source-code file. The .class file is the compiled Java program.
3.
Create an HTML document containing the <applet> tag for the applet you want to run (see the
following example). Save this HTML document in the C:\CLASSES directory.
4.
To run the applet, type appletviewer filename.html, where filename.html is the
name of the HTML document containing your applet's <applet> tag.

5.
You can usually use the same HTML document for each applet just by changing the name of the applet
in the document. Here is an example of a simple HTML document that will load and run an applet:
<applet
code="filename.class"
width=250
height=250>
</applet>
In this HTML document, filename.class is the name of the compiled applet you want to run. Just
change this file name for a new applet, and you're ready to go. You can also set the size of the applet
when it runs by changing the values following the width and height parameters.
Running a Java stand-alone application is a little different. To compile the application, follow steps 1
through 3 above. To run the application type the command java filename, where filename is the
name of the compiled Java application minus the .class file extension. This command line invokes the
Java interpreter rather than the Appletviewer application.
A Word to the Wise
As every programmer knows, a good program is virtually crash-proof. Error checking must be done for
every action that may fail, and appropriate error messages must be given to the user. Unfortunately, good
error checking requires a lot of extra program code. For the programmer working on his next magnum
o
opus, this is all just part of the game. But for an author writing a programming book, this extra code has
different implications.
A programming book should present its topics in as clear a manner as possible. This means featuring
programs whose source code is not obscured by a lot of details that don't apply directly to the topic at
hand. For this reason, the programs in this book do not always employ proper error checking. For
example, user input often goes unverified and dynamic construction of objects is assumed to be
successful.
In short, if you use any of the code in this book in your own programs, it's up to you to add whatever
error checking may have been left out. Never assume anything in your programs. Any place in your code
that you can't be 100 percent sure of your program's state, you must add error checking to ensure that the

program doesn't come crashing down on your user. Just because this book's author may have been lax in
his error checking (for good reasons), does not let you off the hook.
On to the Wonderful World of Java
If you're still reading this introduction, you're probably convinced that Java is something you really want
to learn about. If you're interested in the Internet, that decision is a wise one. (If, on the other hand, you
thought this was a book of coffee recipes, return this book to the shelf and leave the store.) At this point,
Java is virtually guaranteed its place in Internet history. Want to know why? Turn the page and keep
reading.
Clayton Walnum, May 1996

o