v
Sams.netLearningCenterabcd
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
M
T W
R
F
S
S
201 West 103rd Street
Indianapolis, Indiana 46290
Laura Lemay
Charles L. Perkins
Teach Yourself
JAVA
in 21 Days
030-4 FM
1/29/96, 8:10 PM
5
i
Sams.netLearningCenterabcd
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
W
R
F S
M T W R
About This Book
This book teaches you all about the Java language and how to use it to create
applets and applications. By the time you get through with this book, you’ll know
enough about Java to do just about anything, inside an applet or out.
Who Should Read This Book
This book is intended for people with at least some basic programming back-
ground, which includes people with years of programming experience or people
with only a small amount of experience. If you understand what variables, loops,
and functions are, you’ll be just fine for this book. The sorts of people who might
want to read this book include you, if
■ You’re a real whiz at HTML, understand CGI programming (in perl,
AppleScript, Visual Basic, or some other popular CGI language) pretty
well, and want to move on to the next level in Web page design.
■ You had some Basic or Pascal in school and you have a basic grasp of
what programming is, but you’ve heard Java is easy to learn, really
powerful, and very cool.
■ You’ve programmed C and C++ for many years, you’ve heard this Java
thing is becoming really popular and you’re wondering what all the fuss
is all about.
■ You’ve heard that Java is really good for Web-based applets, and you’re
curious about how good it is for creating more general applications.
What if you know programming, but you don’t know object-oriented program-
ming? Fear not. This book assumes no background in object-oriented design. If
you know object-oriented programming, in fact, the first couple of days will be
easy for you.
How This Book Is Structured
This book is intended to be read and absorbed over the course of three weeks.
During each week, you’ll read seven chapters that present concepts related to the
Java language and the creation of applets and applications.
030-4 FM
1/29/96, 8:10 PM
1
Teach Yourself JAVA in 21 Days
M T
W T
F
S
S
21
ii
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
Conventions
Note: A Note box presents interesting pieces of information related to the surround-
ing discussion.
Technical Note: A Technical Note presents specific technical information related to
the surrounding discussion.
Tip: A Tip box offers advice or teaches an easier way to do something.
Caution: A Caution box alerts you to a possible problem and gives you advice to
avoid it.
Warning: A Warning box advises you about potential problems and helps you steer
clear of disaster.
New terms are introduced in New Term boxes, with the term in italics.
A type icon identifies some new HTML code that you can type in yourself.
An Output icon highlights what the same HTML code looks like when viewed by
either Netscape or Mosaic.
An analysis icon alerts you to the author’s line-by-line analysis.
!!
Analysis
Output
Type
NEW
TERM
☛
030-4 FM
1/29/96, 8:10 PM
2
Teach Yourself JAVA in 21 Days
M T
W T
F
S
S
21
vi
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
To Eric, for all the usual reasons
(moral support, stupid questions, comfort in dark times).
LL
For RKJP, ARL, and NMH
the three most important people in my life.
CLP
Copyright ©1996 by Sams.net
Publishing and its licensors
FIRST EDITION
All rights reserved. No part of this book shall be reproduced, stored in a
retrieval system, or transmitted by any means, electronic, mechanical,
photocopying, recording, or otherwise, without written permission from
the publisher. No patent liability is assumed with respect to the use of the
information contained herein. Although every precaution has been taken in
the preparation of this book, the publisher and authors assume no
responsibility for errors or omissions. Neither is any liability assumed for
damages resulting from the use of the information contained herein. For
information, address Sams.net Publishing, 201 W. 103rd St., Indianapolis,
IN 46290.
International Standard Book Number: 1-57521-030-4
Library of Congress Catalog Card Number: 95-78866
99 98 97 96
4 3 2 1
Interpretation of the printing code: the rightmost double-digit number is
the year of the book’s printing; the rightmost single-digit, the number of
the book’s printing. For example, a printing code of 96-1 shows that the
first printing of the book occurred in 1996.
Composed in AGaramond and MCPdigital by Macmillan Computer
Publishing
Printed in the United States of America
All terms mentioned in this book that are known to be trademarks or
service marks have been appropriately capitalized. Sams.net Publishing
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.
President, Sams Publishing:
Richard K. Swadley
Publisher, Sams.net Publishing: George Bond
Publishing Manager: Mark Taber
Managing Editor:
Cindy Morrow
Marketing Manager:
John Pierce
Acquisitions Editor
Mark Taber
Development Editor
Fran Hatton
Software Development
Specialist
Merle Newlon
Production Editor
Nancy Albright
Technical Reviewer
Patrick Chan
Editorial Coordinator
Bill Whitmer
Technical Edit
Coordinator
Lynette Quinn
Formatter
Frank Sinclair
Editorial Assistant
Carol Ackerman
Cover Designer
Tim Amrhein
Book Designer
Alyssa Yesh
Production Team
Supervisor
Brad Chinn
Production
Michael Brumitt
Jason Hand
Cheryl Moore
Ayanna Lacey
Nancy Price
Bobbi Satterfield
Tim Taylor
Susan Van Ness
Mark Walchle
Todd Wente
Indexer
Tim Griffin
030-4 FM
1/29/96, 8:10 PM
6
vii
Sams.netLearningCenterabcd
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
M
T W
R
F
S
S
Overview
Introduction
xxi
Week 1 at a Glance
Day
1
An Introduction to Java Programming
3
2
Object-Oriented Programming and Java
19
3
Java Basics
41
4
Working with Objects
61
5
Arrays, Conditionals, and Loops
79
6
Creating Classes and Applications in Java
95
7
More About Methods
111
Week 2 at a Glance
Day
8
Java Applet Basics
129
9
Graphics, Fonts, and Color
149
10
Simple Animation and Threads
173
11
More Animation, Images, and Sound
195
12
Managing Simple Events and Interactivity
217
13
User Interfaces with the Java Abstract Windowing Toolkit
237
14
Windows, Networking, and Other Tidbits
279
Week 3 at a Glance
Day
15
Modifiers
305
16
Packages and Interfaces
323
17
Exceptions
341
18
Multithreading
353
19
Streams
375
20
Native Methods and Libraries
403
21
Under the Hood
421
Appendixes
A
Language Summary
473
B
The Java Class Library
483
C
How Java Differs from C and C++
497
D
How Java Differs from C and C++
507
Index
511
030-4 FM
1/29/96, 8:11 PM
7
ix
Sams.netLearningCenterabcd
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
M
T W
R
F
S
S
Contents
Introduction
xxi
Week 1 at a Glance
1
Day
1
An Introduction to Java Programming
3
What Is Java? .............................................................................................. 4
Java’s Past, Present, and Future ................................................................... 6
Why Learn Java? ......................................................................................... 7
Java Is Platform-Independent................................................................. 7
Java Is Object-Oriented ......................................................................... 9
Java Is Easy to Learn .............................................................................. 9
Getting Started with
Programming in Java .............................................................................. 10
Getting the Software ............................................................................ 10
Applets and Applications ..................................................................... 11
Creating a Java Application .................................................................. 11
Creating a Java Applet ......................................................................... 13
Summary .................................................................................................. 16
Q&A ........................................................................................................ 16
Day
2
Object-Oriented Programming and Java
19
Thinking in Objects: An Analogy ............................................................. 20
Objects and Classes .................................................................................. 21
Behavior and Attributes ............................................................................ 23
Attributes ............................................................................................. 23
Behavior .............................................................................................. 24
Creating a Class ................................................................................... 24
Inheritance, Interfaces, and Packages ........................................................ 28
Inheritance........................................................................................... 29
Creating a Class Hierarchy................................................................... 30
How Inheritance Works ...................................................................... 32
Single and Multiple Inheritance ........................................................... 34
Interfaces and Packages ........................................................................ 34
Creating a Subclass ................................................................................... 35
Summary .................................................................................................. 38
Q&A ........................................................................................................ 39
Day
3
Java Basics
41
Statements and Expressions ...................................................................... 42
Variables and Data Types ......................................................................... 43
Declaring Variables .............................................................................. 43
Notes on Variable Names .................................................................... 44
030-4 FM
1/29/96, 8:11 PM
9
Teach Yourself JAVA in 21 Days
M T
W T
F
S
S
21
x
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
Variable Types ..................................................................................... 45
Assigning Values to Variables ............................................................... 46
Comments ................................................................................................ 47
Literals ...................................................................................................... 47
Number Literals ................................................................................... 47
Boolean Literals ................................................................................... 48
Character Literals ................................................................................. 48
String Literals ...................................................................................... 49
Expressions and Operators ........................................................................ 50
Arithmetic ........................................................................................... 50
More About Assignment ...................................................................... 52
Incrementing and Decrementing ......................................................... 52
Comparisons ........................................................................................ 54
Logical Operators ................................................................................ 55
Bitwise Operators ................................................................................ 55
Operator Precedence ............................................................................ 56
String Arithmetic ...................................................................................... 57
Summary .................................................................................................. 58
Q&A ........................................................................................................ 60
Day
4
Working with Objects
61
Creating New Objects .............................................................................. 62
Using new ............................................................................................ 63
What new Does ................................................................................... 64
A Note on Memory Management ........................................................ 64
Accessing and Setting Class and Instance Variables ................................... 65
Getting Values ..................................................................................... 65
Changing Values .................................................................................. 65
Class Variables ..................................................................................... 66
Calling Methods ....................................................................................... 67
Class Methods ..................................................................................... 69
References to Objects ............................................................................... 70
Casting and Converting Objects and Primitive Types .............................. 71
Casting Primitive Types ...................................................................... 71
Casting Objects .................................................................................. 72
Converting Primitive Types
to Objects and Vice Versa ................................................................. 73
Odds and Ends ......................................................................................... 73
Comparing Objects ............................................................................. 74
Copying Objects .................................................................................. 75
Determining the Class of an Object ..................................................... 76
The Java Class Libraries ............................................................................ 76
Summary .................................................................................................. 77
Q&A ........................................................................................................ 78
030-4 FM
1/29/96, 8:11 PM
10
xi
Sams.netLearningCenterabcd
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
Day
5
Arrays, Conditionals, and Loops
79
Arrays ....................................................................................................... 80
Declaring Array Variables .................................................................... 80
Creating Array Objects ........................................................................ 81
Accessing Array Elements ..................................................................... 81
Changing Array Elements .................................................................... 82
Multidimensional Arrays...................................................................... 83
Block Statements ...................................................................................... 83
if Conditionals .......................................................................................... 83
The Conditional Operator ................................................................... 84
switch Conditionals ................................................................................... 85
for Loops .................................................................................................. 86
while and do Loops ................................................................................... 88
while Loops .......................................................................................... 88
do...while Loops ................................................................................... 89
Breaking Out of Loops ............................................................................. 89
Labeled Loops ...................................................................................... 90
Summary .................................................................................................. 91
Q&A ........................................................................................................ 92
Day
6
Creating Classes and Applications in Java
95
Defining Classes ....................................................................................... 96
Creating Instance and Class Variables ....................................................... 96
Defining Instance Variables ................................................................. 97
Constants ............................................................................................. 97
Class Variables ..................................................................................... 98
Creating Methods ..................................................................................... 99
Defining Methods ............................................................................... 99
The this Keyword ............................................................................... 101
Variable Scope and Method Definitions ............................................ 101
Passing Arguments to Methods .......................................................... 102
Class Methods ................................................................................... 104
Creating Java Applications ...................................................................... 105
Java Applications and Command-Line Arguments ................................. 106
Passing Arguments to Java Programs .................................................. 106
Handling Arguments in Your Java Program ....................................... 106
Summary ................................................................................................ 108
Q&A ...................................................................................................... 109
Day
7
More About Methods
111
Creating Methods with the Same Name, Different Arguments ............... 112
Constructor Methods ............................................................................. 115
Basic Constructors ............................................................................. 116
Calling Another Constructor ............................................................. 117
Overloading Constructors .................................................................. 117
030-4 FM
1/29/96, 8:11 PM
11
Teach Yourself JAVA in 21 Days
M T
W T
F
S
S
21
xii
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
Overriding Methods ............................................................................... 119
Creating Methods that Override Existing Methods ............................ 119
Calling the Original Method ............................................................. 121
Overriding Constructors .................................................................... 122
Finalizer Methods ................................................................................... 123
Summary ................................................................................................ 124
Q&A ...................................................................................................... 124
Week 2 at a Glance
127
Day
8
Java Applet Basics
129
How Applets and Applications Are Different .......................................... 130
Creating Applets ..................................................................................... 131
Major Applet Activities ...................................................................... 132
A Simple Applet................................................................................. 134
Including an Applet on a Web Page ........................................................ 136
The Tag.......................................................................... 136
Testing the Result .............................................................................. 137
Making Java Applets Available to the Web......................................... 137
More About the Tag ............................................................ 138
ALIGN .............................................................................................. 138
HSPACE and VSPACE ...................................................................... 140
CODE and CODEBASE .................................................................... 141
Passing Parameters to Applets ................................................................. 141
Summary ................................................................................................ 146
Q&A ...................................................................................................... 147
Day
9
Graphics, Fonts, and Color
149
The Graphics Class ................................................................................. 150
The Graphics Coordinate System ...................................................... 151
Drawing and Filling ............................................................................... 151
Lines .................................................................................................. 152
Rectangles .......................................................................................... 152
Polygons ............................................................................................ 155
Ovals ................................................................................................. 156
Arc ..................................................................................................... 157
A Simple Graphics Example............................................................... 161
Copying and Clearing ........................................................................ 163
Text and Fonts ....................................................................................... 163
Creating Font Objects ....................................................................... 163
Drawing Characters and Strings ......................................................... 164
Finding Out Information About a Font ............................................. 166
Color ...................................................................................................... 168
Using Color Objects .......................................................................... 168
Testing and Setting the Current Colors ............................................. 169
A Single Color Example ..................................................................... 170
Summary ................................................................................................ 171
Q&A ...................................................................................................... 171
030-4 FM
1/29/96, 8:11 PM
12
xiii
Sams.netLearningCenterabcd
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
Day
10
Simple Animation and Threads
173
Creating Animation in Java .................................................................... 174
Painting and Repainting .................................................................... 174
Starting and Stopping
an Applet’s Execution ...................................................................... 175
Putting It Together ............................................................................ 175
Threads: What They Are
and Why You Need Them ................................................................... 177
The Problem with the Digital Clock Applet ...................................... 178
Writing Applets with Threads ............................................................ 179
Fixing The Digital Clock ................................................................... 180
Reducing Animation Flicker ................................................................... 182
Flicker and How to Avoid It .............................................................. 182
How to Override Update ................................................................... 183
Solution One: Don’t Clear the Screen ............................................... 183
Solution Two: Redraw
Only What You Have To ................................................................ 186
Summary ................................................................................................ 192
Q&A ...................................................................................................... 192
Day
11
More Animation, Images, and Sound
195
Retrieving and Using Images .................................................................. 196
Getting Images .................................................................................. 196
Drawing Images ................................................................................. 198
Modifying Images .............................................................................. 201
Creating Animation Using Images .......................................................... 201
An Example: Neko............................................................................. 201
Retrieving and Using Sounds .................................................................. 209
Sun’s Animator Applet ........................................................................... 211
More About Flicker: Double-Buffering................................................... 212
Creating Applets with Double-Buffering............................................ 212
An Example: Checkers Revisited ........................................................ 213
Summary ................................................................................................ 214
Q&A ...................................................................................................... 215
Day
12
Managing Simple Events and Interactivity
217
Mouse Clicks .......................................................................................... 218
mouseDown and mouseUp................................................................... 219
An Example: Spots ............................................................................. 220
Mouse Movements ................................................................................. 223
mouseDrag and mouseMove ................................................................. 223
mouseEnter and mouseExit .................................................................. 223
An Example: Drawing Lines .............................................................. 224
Keyboard Events ..................................................................................... 228
The keyDown Method ....................................................................... 228
Default Keys ...................................................................................... 229
030-4 FM
1/29/96, 8:11 PM
13
Teach Yourself JAVA in 21 Days
M T
W T
F
S
S
21
xiv
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
An Example: Entering, Displaying, and Moving Characters .............. 229
Testing for Modifier Keys .................................................................. 232
The AWT Event Handler ....................................................................... 233
Summary ................................................................................................ 235
Q&A ...................................................................................................... 235
Day
13
The Java Abstract Windowing Toolkit
237
An AWT Overview................................................................................. 238
The Basic User Interface Components .................................................... 240
Labels ................................................................................................ 241
Buttons .............................................................................................. 242
Checkboxes ........................................................................................ 243
Radio Buttons .................................................................................... 244
Choice Menus ................................................................................... 245
Text Fields ......................................................................................... 247
Panels and Layout ................................................................................... 249
Layout Managers ............................................................................... 249
Insets ................................................................................................. 254
Handling UI Actions and Events ............................................................ 255
Nesting Panels and Components ............................................................ 258
Nested Panels .................................................................................... 258
Events and Nested Panels .................................................................. 258
More UI Components ............................................................................ 259
Text Areas .......................................................................................... 259
Scrolling Lists .................................................................................... 261
Scrollbars and Sliders ......................................................................... 262
Canvases ............................................................................................ 265
More UI Events ...................................................................................... 265
A Complete Example:
RGB to HSB Converter ....................................................................... 266
Create the Applet Layout ................................................................... 267
Create the Panel Layout ..................................................................... 267
Define the Subpanels ......................................................................... 269
Handle the Actions ............................................................................ 272
Update the Result .............................................................................. 272
The Complete Source Code ............................................................... 274
Summary ................................................................................................ 277
Q&A ...................................................................................................... 277
Day
14
Windows, Networking, and Other Tidbits
279
Windows, Menus, and Dialog Boxes ...................................................... 280
Frames ............................................................................................... 280
Menus ............................................................................................... 282
Dialog Boxes ...................................................................................... 285
File Dialogs ........................................................................................ 287
Window Events ................................................................................. 288
Using AWT Windows in Stand-Alone Applications .......................... 288
030-4 FM
1/29/96, 8:11 PM
14
xv
Sams.netLearningCenterabcd
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
Networking in Java ................................................................................. 289
Creating Links Inside Applets ............................................................ 290
Opening Web Connections ............................................................... 292
openStream() ...................................................................................... 293
The URLconnection Class ................................................................... 296
Sockets ............................................................................................... 296
Other Applet Hints ................................................................................ 297
The showStatus Method ..................................................................... 297
Applet Information ............................................................................ 298
Communicating Between Applets ...................................................... 298
Summary ................................................................................................ 299
Q&A ...................................................................................................... 300
Week 3 at a Glance
303
Day
15
Modifiers
305
Method and Variable Access Control ...................................................... 307
The Four P’s of Protection ................................................................. 307
The Conventions for Instance Variable Access ................................... 312
Class Variables and Methods .................................................................. 314
The final Modifier .................................................................................. 316
final Classes ....................................................................................... 316
final Variables .................................................................................... 317
final Methods .................................................................................... 317
abstract Methods and Classes .................................................................. 319
Summary ................................................................................................ 320
Q&A ...................................................................................................... 320
Day
16
Packages and Interfaces
323
Packages ................................................................................................. 324
Programming in the Large ................................................................. 324
Programming in the Small ................................................................. 327
Hiding Classes ................................................................................... 329
Interfaces ................................................................................................ 331
Programming in the Large ................................................................. 331
Programming in the Small ................................................................. 335
Summary ................................................................................................ 338
Q&A ...................................................................................................... 339
Day
17
Exceptions
341
Programming in the Large ...................................................................... 342
Programming in the Small ...................................................................... 345
The Limitations Placed on the Programmer ........................................... 348
The finally Clause ................................................................................... 349
Summary ................................................................................................ 350
Q&A ...................................................................................................... 351
030-4 FM
1/29/96, 8:11 PM
15
Teach Yourself JAVA in 21 Days
M T
W T
F
S
S
21
xvi
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
Day
18
Multithreading
353
The Problem with Parallelism ................................................................. 354
Thinking Multithreaded ......................................................................... 355
Points About Points ........................................................................... 357
Protecting a Class Variable ................................................................. 360
Creating and Using Threads ................................................................... 361
The Runnable Interface ...................................................................... 362
ThreadTester ...................................................................................... 363
NamedThreadTester ........................................................................... 365
Knowing When a Thread has Stopped ................................................... 366
Thread Scheduling ................................................................................. 367
Preemptive Versus Nonpreemptive .................................................... 367
Testing Your Scheduler ...................................................................... 368
Summary ................................................................................................ 371
Q&A ...................................................................................................... 372
Day
19
Streams
375
Input Streams ......................................................................................... 377
The abstract Class InputStream ........................................................... 377
ByteArrayInputStream ......................................................................... 381
FileInputStream .................................................................................. 382
FilterInputStream ............................................................................... 383
PipedInputStream ............................................................................... 389
SequenceInputStream .......................................................................... 389
StringBufferInputStream ..................................................................... 390
Output Streams ...................................................................................... 391
The abstract Class OutputStream ........................................................ 391
ByteArrayOutputStream ...................................................................... 392
FileOutputStream ............................................................................... 393
FilterOutputStream............................................................................. 394
PipedOutputStream ............................................................................ 399
Related Classes ....................................................................................... 399
Summary ................................................................................................ 399
Q&A ...................................................................................................... 400
Day
20
Native Methods and Libraries
403
Disadvantages of native Methods ............................................................ 404
The Illusion of Required Efficiency ........................................................ 405
Built-In Optimizations ...................................................................... 407
Simple Optimization Tricks............................................................... 407
Writing native Methods .......................................................................... 408
The Example Class ............................................................................ 409
Generating Header and Stub Files ..................................................... 410
Creating SimpleFileNative.c .............................................................. 414
030-4 FM
1/29/96, 8:11 PM
16
xvii
Sams.netLearningCenterabcd
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
A Native Library ..................................................................................... 417
Linking It All ..................................................................................... 418
Using Your Library ............................................................................ 418
Summary ................................................................................................ 418
Q&A ...................................................................................................... 419
Day
21
Under the Hood
421
The Big Picture ...................................................................................... 422
Why It’s a Powerful Vision ................................................................ 423
The Java Virtual Machine ....................................................................... 423
An Overview ...................................................................................... 424
The Fundamental Parts ...................................................................... 426
The Constant Pool ............................................................................ 430
Limitations ........................................................................................ 430
Bytecodes in More Detail ....................................................................... 431
The Bytecode Interpreter ................................................................... 431
The “Just-in-Time” Compiler ............................................................ 432
The java2c Translator ........................................................................ 433
The Bytecodes Themselves ................................................................ 434
The _quick Bytecodes ........................................................................ 450
The .class File Format ............................................................................. 452
Method Signatures ................................................................................. 454
The Garbage Collector ........................................................................... 455
The Problem ...................................................................................... 455
The Solution ...................................................................................... 456
Java’s Parallel Garbage Collector ........................................................ 459
The Security Story .................................................................................. 459
Why You Should Worry .................................................................... 459
Why You Might Not Have To .......................................................... 460
Java’s Security Model ......................................................................... 460
Summary ................................................................................................ 470
Q&A ...................................................................................................... 470
A
Language Summary
473
Reserved Words ...................................................................................... 474
Comments .............................................................................................. 475
Literals .................................................................................................... 475
Variable Declaration ............................................................................... 476
Variable Assignment ............................................................................... 476
Operators ............................................................................................... 477
Objects ................................................................................................... 478
Arrays ..................................................................................................... 478
Loops and Conditionals .......................................................................... 478
Class Definitions .................................................................................... 479
Method and Constructor Definitions ..................................................... 479
Packages, Interfaces, and Importing ........................................................ 480
Exceptions and Guarding ....................................................................... 481
030-4 FM
1/29/96, 8:12 PM
17
Teach Yourself JAVA in 21 Days
M T
W T
F
S
S
21
xviii
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
B
Class Hierarchy Diagrams
483
About These Diagrams ........................................................................... 495
C
The Java Class Library
497
java.lang ................................................................................................. 498
Interfaces ........................................................................................... 498
Classes ............................................................................................... 498
java.util .................................................................................................. 499
Interfaces ........................................................................................... 499
Classes ............................................................................................... 499
java.io ..................................................................................................... 500
Interfaces ........................................................................................... 500
Classes ............................................................................................... 500
java.net ................................................................................................... 501
Interfaces ........................................................................................... 501
Classes ............................................................................................... 502
java.awt .................................................................................................. 502
Interfaces ........................................................................................... 502
Classes ............................................................................................... 502
java.awt.image ........................................................................................ 504
Interfaces ........................................................................................... 504
Classes ............................................................................................... 504
java.awt.peer ........................................................................................... 505
java.applet ............................................................................................... 505
Interfaces ........................................................................................... 505
Classes ............................................................................................... 505
D How Java Differs from C and C++
507
Pointers .................................................................................................. 508
Arrays ..................................................................................................... 508
Strings .................................................................................................... 508
Memory Management ............................................................................ 509
Data Types ............................................................................................. 509
Operators ............................................................................................... 509
Control Flow .......................................................................................... 510
Arguments .............................................................................................. 510
Other Differences ................................................................................... 510
Index
511
030-4 FM
1/29/96, 8:12 PM
18
xix
Sams.netLearningCenterabcd
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
Acknowledgments
From Laura Lemay:
To Sun’s Java team, for all their hard work on Java the language and on the browser, and
particularly to Jim Graham, who demonstrated Java and HotJava to me on very short notice in
May and planted the idea for this book.
To everyone who bought my previous books, and liked them. Buy this one too.
From Charles L. Perkins:
To Patrick Naughton, who first showed me the power and the promise of OAK (Java) in early
1993.
To Mark Taber, who shepherded this lost sheep through his first book.
030-4 FM
1/29/96, 8:12 PM
19
Teach Yourself JAVA in 21 Days
M T
W T
F
S
S
21
xx
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
About the Authors
Laura Lemay is a technical writer and a nerd. After spending six years writing software
documentation for various computer companies in Silicon Valley, she decided writing books
would be much more fun (but has still not yet made up her mind). In her spare time she collects
computers, e-mail addresses, interesting hair colors, and nonrunning motorcycles. She is also the
perpetrator of Teach Yourself Web Publishing with HTML in 14 Days.
You can reach her by e-mail at lemay@lne.com, or visit her home page at http://www.lne.com/
lemay/.
Charles L. Perkins is the founder of Virtual Rendezvous, a company building what it spent two
years designing: a software layer above Java that will foster socially focused, computer-mediated,
real-time filtered interactions between people’s personas in the virtual environments of the near
future. In previous lives, he has evangelized NeXTSTEP, Smalltalk, and UNIX, and has degrees
in both physics and computer science. Before attempting this book, he was an amateur
columnist and author. He’s done research in speech recognition, neural nets, gestural user
interfaces, computer graphics, and language theory, but had the most fun working at Thinking
Machines and Xerox PARC’s Smalltalk group. In his spare time, he reads textbooks for fun.
You can reach him via e-mail at virtual@rendezvous.com, or visit his Java page at http://
rendezvous.com/java.
030-4 FM
1/29/96, 8:12 PM
20
xxi
Sams.netLearningCenterabcd
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
Introduction
The World Wide Web, for much of its existence, has been a method for distributing passive
information to a widely distributed number of people. The Web has, indeed, been exceptionally
good for that purpose. With the addition of forms and image maps, Web pages began to become
interactive—but the interaction was often simply a new way to get at the same information. The
limitations of Web distribution were all too apparent once designers began to try to stretch the
boundaries of what the Web can do. Even other innovations, such as Netscape’s server push to
create dynamic animations, were merely clever tricks layered on top of a framework that wasn’t
built to support much other than static documents with images and text.
Enter Java, and the capability for Web pages of containing Java applets. Applets are small
programs that create animations, multimedia presentations, real-time (video) games, multi-user
networked games, and real interactivity—in fact, most anything a small program can do, Java
applets can. Downloaded over the net and executed inside a Web page by a browser that supports
Java, applets are an enormous step beyond standard Web design.
The disadvantage of Java is that to create Java applets right now, you need to write them in the
Java language. Java is a programming language, and as such, creating Java applets is more
difficult than creating a Web page or a form using HTML. Soon there will be tools and programs
that will make creating Java applets easier—they may be available by the time you read this. For
now, however, the only way to delve into Java is to learn the language and start playing with the
raw Java code. Even when the tools come out, you may want to do more with Java than the tools
can provide, and you’re back to learning the language.
That’s where Teach Yourself Java in 21 Days comes in. This book teaches you all about the Java
language and how to use it to create not only applets, but also applications, which are more
general Java programs that don’t need to run inside a Web browser. By the time you get through
with this book, you’ll know enough about Java to do just about anything, inside an applet or
out.
Who Should Read This Book
Teach Yourself Java in 21 Days is intended for people with at least some basic programming
background—which includes people with years of programming experience and people with
only a small amount of experience. If you understand what variables, loops, and functions are,
you’ll be just fine for this book. The sorts of people who might want to read this book include
you, if one or more of the following is true:
■ You’re a real whiz at HTML, understand CGI programming (in perl, AppleScript,
Visual Basic, or some other popular CGI language) pretty well, and want to move
onto the next level in Web page design.
030-4 FM
1/29/96, 8:12 PM
21
Teach Yourself JAVA in 21 Days
M T
W T
F
S
S
21
xxii
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
■ You had some Basic or Pascal in school, you’ve got a basic grasp of what programming
is, but you’ve heard Java is easy to learn, really powerful, and very cool.
■ You’ve programmed C and C++ for many years, you’ve heard this Java thing is
becoming really popular, and you’re wondering what all the fuss is all about.
■ You’ve heard that Java is really good for Web-based applets, and you’re curious about
how good it is for creating more general applications.
What if you know programming, but you don’t know object-oriented programming? Fear not.
Teach Yourself Java in 21 Days assumes no background in object-oriented design. If you know
object-oriented programming, the first couple of days will be easy for you.
What if you’re a rank beginner? This book might move a little fast for you. Java is a good language
to start with, though, and if you take it slow and work through all the examples, you may still
be able to pick up Java and start creating your own applets.
How This Book Is Organized
Teach Yourself Java in 21 Days describes Java primarily in its current state—what’s known as the
beta API (Application Programming Interface). This is the version of Java that Netscape and
other browsers, such as Spyglass’s Mosaic, support. A previous version of Java, the alpha API,
was significantly different from the version described in this book, and the two versions are not
compatible with each other. There are other books that describe only the alpha API, and there
may still be programs and browsers out there that can only run using alpha Java programs.
Teach Yourself Java in 21 Days uses primarily Java beta because that is the version that is most
current and is the version that will continue to be used in the future. The alpha API is obsolete
and will eventually die out. If you learn Java using beta API, you’ll be much better prepared for
any future changes (which will be minor) than if you have to worry about both APIs at once.
Java is still in development. “Beta” means that Java is not complete and that things may change
between the time this book is being written and the time you read this. Keep this in mind as you
work with Java and with the software you’ll use to create and compile programs. If things aren’t
behaving the way you expect, check the Web sites mentioned at the end of this introduction for
more information.
Teach Yourself Java in 21 Days covers the Java language and its class libraries in 21 days, organized
as three separate weeks. Each week covers a different broad area of developing Java applets and
applications.
In the first week, you’ll learn about the Java language itself:
■ Day 1 is the basic introduction: what Java is, why it’s cool, and how to get the
software. You’ll also create your first Java applications and applets.
030-4 FM
1/29/96, 8:12 PM
22
xxiii
Sams.netLearningCenterabcd
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
■ On Day 2, you’ll explore basic object-oriented programming concepts as they apply to
Java.
■ On Day 3, you start getting down to details with the basic Java building blocks: data
types, variables, and expressions such as arithmetic and comparisons.
■ Day 4 goes into detail about how to deal with objects in Java: how to create them,
how to access their variables and call their methods, and how to compare and copy
them. You’ll also get your first glance at the Java class libraries.
■ On Day 5, you’ll learn more about Java with arrays, conditional statements. and
loops.
■ Day 6 is the best one yet. You’ll learn how to create classes, the basic building blocks
of any Java program, as well as how to put together a Java application (an application
being a Java program that can run on its own without a Web browser).
■ Day 7 builds on what you learned on Day 6. On Day 7, you’ll learn more about how
to create and use methods, including overriding and overloading methods and
creating constructors.
Week 2 is dedicated to applets and the Java class libraries:
■ Day 8 provides the basics of applets—how they’re different from applications, how to
create them, and the most important parts of an applet’s life cycle. You’ll also learn
how to create HTML pages that contain Java applets.
■ On Day 9, you’ll learn about the Java classes for drawing shapes and characters to the
screen—in black, white, or any other color.
■ On Day 10, you’ll start animating those shapes you learned about on Day 9, includ-
ing learning what threads and their uses are.
■ Day 11 covers more detail about animation, adding bitmap images and audio to the
soup.
■ Day 12 delves into interactivity—handling mouse and keyboard clicks from the user
in your Java applets.
■ Day 13 is ambitious; on that day you’ll learn about using Java’s Abstract Windowing
Toolkit to create a user interface in your applet including menus, buttons, checkboxes,
and other elements.
■ On Day 14, you explore the last of the main Java class libraries for creating applets:
windows and dialogs, networking, and a few other tidbits.
Week 3 finishes up with advanced topics, for when you start doing larger and more complex Java
programs, or when you want to learn more:
■ On Day 15, you’ll learn more about the Java language’s modifiers—for abstract and
final methods and classes as well as for protecting a class’s private information from
the prying eyes of other classes.
030-4 FM
1/29/96, 8:12 PM
23
Teach Yourself JAVA in 21 Days
M T
W T
F
S
S
21
xxiv
P2/V4SQC6 TY Java in 21 Days 030-4 louisa 12.31.95
FM LP#4
■ Day 16 covers interfaces and packages, useful for abstracting protocols of methods to
aid reuse and for the grouping and categorization of classes.
■ Day 17 covers exceptions: errors and warnings and other abnormal conditions,
generated either by the system or by you in your programs.
■ Day 18 builds on the thread basics you learned on Day 10 to give a broad overview of
multithreading and how to use it to allow different parts of your Java programs to run
in parallel.
■ On Day 19, you’ll learn all about the input and output streams in Java’s I/O library.
■ Day 20 teaches you about native code—how to link C code into your Java programs
to provide missing functionality or to gain performance.
■ Finally, on Day 21, you’ll get an overview of some of the “behind-the-scenes” techni-
cal details of how Java works: the bytecode compiler and interpreter, the techniques
Java uses to ensure the integrity and security of your programs, and the Java garbage
collector.
Conventions Used in This Book
Text that you type and text that should appear on your screen is presented in monospace type:
It will look like this.
to mimic the way text looks on your screen. Variables and placeholders will appear in monospace
italic.
The end of each chapter offers common questions asked about that day’s subject matter with
answers from the authors.
Web Sites for Further Information
Before, while, and after you read this book, there are two Web sites that may be of interest to
you as a Java developer.
The official Java web site is at http://java.sun.com/. At this site, you’ll find the Java
development software, the HotJava web browser, and online documentation for all aspects of
the Java language. It has several mirror sites that it lists online, and you should probably use the
site “closest” to you on the Internet for your downloading and Java Web browsing. There is also
a site for developer resources, called Gamelan, at http://www.gamelan.com/.
This book also has a companion Web site at http://www.lne.com/Web/Java/. Information at
that site includes examples, more information and background for this book, corrections to this
book, and other tidbits that were not included here.
030-4 FM
1/29/96, 8:12 PM
24
1
Sams.netLearningCenterabcd
P2/V4/sqc8 TY Java in 21 Days 030-4 Everly 12.11.95 AAG1 LP#2
M
T W
R
F
S
S
■ An Introduction to Java Programming
Platform independence
The Java compiler and the java interpreter
■ Object-Oriented Programming and Java
Objects and classes
Encapsulation
Modularity
■ Java Basics
Java statements and expressions
Variables and data types
Comparisons and logical operators
■ Working with Objects
Testing and modifying instance variables
Converting objects
■ Arrays, Conditionals, and Loops
Conditional tests
Iteration
Block statements
WEEK
AT A GLANCE2
3
4
5
6
7
1
1
030-4s AAG 01
1/29/96, 8:13 PM
1
2
Week 1 at a Glance
M
T W
R
F
S
S
WEEK
1
P2/V4/sqc8 TY Java in 21 Days 030-4 Everly 12.11.95 AAG1 LP#2
■ Creating Classes and Applications in Java
Defining constants, instance and class
variables, and methods
■ More About Methods
Overloading methods
Constructor methods
Overriding methods
030-4s AAG 01
1/29/96, 8:13 PM
2
3
Sams.netLearningCenterabcd
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
M
T W
R
F
S
S
An Introduction to
Java Programming
by Laura Lemay
WEEK
1
1
030-4s CH01.i
1/29/96, 8:34 PM
3
4
An Introduction to Java Programming
M
T W
R
F
S
S
DAY
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
Hello and welcome to Teach Yourself Java in 21 Days! Starting today and for the next three weeks
you’ll learn all about the Java language and how to use it to create applets, as well as how to create
stand-alone Java applications that you can use for just about anything.
An applet is a dynamic and interactive program that can run inside a Web page displayed
by a Java-capable browser such as HotJava or Netscape 2.0.
The HotJava browser is a World Wide Web browser used to view Web pages, follow links, and
submit forms. It can also download and play applets on the reader’s system.
That’s the overall goal for the next three weeks. Today, the goals are somewhat more modest,
and you’ll learn about the following:
■ What exactly Java and HotJava are, and their current status
■ Why you should learn Java—its various features and advantages over other program-
ming languages
■ Getting started programming in Java—what you’ll need in terms of software and
background, as well as some basic terminology
■ How to create your first Java programs—to close this day, you’ll create both a simple
Java application and a simple Java applet!
What Is Java?
Java is an object-oriented programming language developed by Sun Microsystems, a company
best known for its high-end Unix workstations. Modeled after C++, the Java language was
designed to be small, simple, and portable across platforms and operating systems, both at the
source and at the binary level (more about this later).
Java is often mentioned in the same breath as HotJava, a World Wide Web browser from Sun
like Netscape or Mosaic (see Figure 1.1). What makes HotJava different from most other
browsers is that, in addition to all its basic Web features, it can also download and play applets
on the reader’s system. Applets appear in a Web page much in the same way as images do, but
unlike images, applets are dynamic and interactive. Applets can be used to create animations,
figures, or areas that can respond to input from the reader, games, or other interactive effects on
the same Web pages among the text and graphics.
Although HotJava was the first World Wide Web browser to be able to play Java applets, Java
support is rapidly becoming available in other browsers. Netscape 2.0 provides support for Java
applets, and other browser developers have also announced support for Java in forthcoming
products.
NEW
TERM
☛
030-4s CH01.i
1/29/96, 8:34 PM
4
5
Sams.netLearningCenterabcd
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
To create an applet, you write it in the Java language, compile it using a Java compiler, and refer
to that applet in your HTML Web pages. You put the resulting HTML and Java files on a Web
site much in the same way that you make ordinary HTML and image files available. Then, when
someone using the HotJava browser (or other Java-aware browser) views your page with the
embedded applet, that browser downloads the applet to the local system and executes it, and
then the reader can view and interact with your applet in all its glory (readers using other
browsers won’t see anything). You’ll learn more about how applets, browsers, and the World
Wide Web work together further on in this book.
The important thing to understand about Java is that you can do so much more with it besides
create applets. Java was written as a full-fledged programming language in which you can
accomplish the same sorts of tasks and solve the same sorts of problems that you can in other
programming languages, such as C or C++. HotJava itself, including all the networking, display,
and user interface elements, is written in Java.
Figure 1.1.
The HotJava browser.
030-4s CH01.i
1/29/96, 8:35 PM
5
6
An Introduction to Java Programming
M
T W
R
F
S
S
DAY
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
Java’s Past, Present, and Future
The Java language was developed at Sun Microsystems in 1991 as part of a research project to
develop software for consumer electronics devices—television sets, VCRs, toasters, and the
other sorts of machines you can buy at any department store. Java’s goals at that time were to
be small, fast, efficient, and easily portable to a wide range of hardware devices. It is those same
goals that made Java an ideal language for distributing executable programs via the World Wide
Web, and also a general-purpose programming language for developing programs that are easily
usable and portable across different platforms.
The Java language was used in several projects within Sun, but did not get very much commercial
attention until it was paired with HotJava. HotJava was written in 1994 in a matter of months,
both as a vehicle for downloading and running applets and also as an example of the sort of
complex application that can be written in Java.
At the time this book is being written, Sun has released the beta version of the Java Developer’s
Kit (JDK), which includes tools for developing Java applets and applications on Sun systems
running Solaris 2.3 or higher for Windows NT and for Windows 95. By the time you read this,
support for Java development may have appeared on other platforms, either from Sun or from
third-party companies.
Note that because the JDK is currently in beta, it is still subject to change between now and when
it is officially released. Applets and applications you write using the JDK and using the examples
in this book may require some changes to work with future versions of the JDK. However,
because the Java language has been around for several years and has been used for several projects,
the language itself is quite stable and robust and most likely will not change excessively. Keep
this beta status in mind as you read through this book and as you develop your own Java
programs.
Support for playing Java programs is a little more confusing at the moment. Sun’s HotJava is
not currently included with the Beta JDK; the only available version of HotJava is an older alpha
version, and, tragically, applets written for the alpha version of Java do not work with the beta
JDK, and vice versa. By the time you read this, Sun may have released a newer version of HotJava
which will enable you to view applets.
The JDK does include an application called appletviewer that allows you to test your Java applets
as you write them. If an applet works in the appletviewer, it should work with any Java-capable
browser. You’ll learn more about applet viewer later today.
What’s in store for the future? In addition to the final Java release from Sun, other companies
have announced support for Java in their own World Wide Web browsers. Netscape Commu-
nications Corporation has already incorporated Java capabilities into the 2.0 version of their very
popular Netscape Navigator Web browser—pages with embedded Java applets can be viewed
and played with Netscape. With support for Java available in as popular a browser as Netscape,
030-4s CH01.i
1/29/96, 8:35 PM
6
7
Sams.netLearningCenterabcd
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
tools to help develop Java applications (debuggers, development environments, and so on) most
likely will be rapidly available as well.
Why Learn Java?
At the moment, probably the most compelling reason to learn Java—and probably the reason
you bought this book—is that HotJava applets are written in Java. Even if that were not the case,
Java as a language has significant advantages over other languages and other programming
environments that make it suitable for just about any programming task. This section describes
some of those advantages.
Java Is Platform-Independent
Platform independence is one of the most significant advantages that Java has over other
programming languages, particularly for systems that need to work on many different platforms.
Java is platform-independent at both the source and the binary level.
Platform-independence is a program’s capability of moving easily from one computer
system to another.
At the source level, Java’s primitive data types have consistent sizes across all development
platforms. Java’s foundation class libraries make it easy to write code that can be moved from
platform to platform without the need to rewrite it to work with that platform.
Platform-independence doesn’t stop at the source level, however. Java binary files are also
platform-independent and can run on multiple problems without the need to recompile the
source. How does this work? Java binary files are actually in a form called bytecodes.
Bytecodes are a set of instructions that looks a lot like some machine codes, but that is not
specific to any one processor.
Normally, when you compile a program written in C or in most other languages, the compiler
translates your program into machine codes or processor instructions. Those instructions are
specific to the processor your computer is running—so, for example, if you compile your code
on a Pentium system, the resulting program will run only on other Pentium systems. If you want
to use the same program on another system, you have to go back to your original source, get a
compiler for that system, and recompile your code. Figure 1.2 shows the result of this system:
multiple executable programs for multiple systems.
Things are different when you write code in Java. The Java development environment has two
parts: a Java compiler and a Java interpreter. The Java compiler takes your Java program and
instead of generating machine codes from your source files, it generates bytecodes.
NEW
TERM
☛
NEW
TERM
☛
030-4s CH01.i
1/29/96, 8:35 PM
7
8
An Introduction to Java Programming
M
T W
R
F
S
S
DAY
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
To run a Java program, you run a program called a bytecode interpreter, which in turn executes
your Java program (see Figure 1.3). You can either run the interpreter by itself, or—for applets—
there is a bytecode interpreter built into HotJava and other Java-capable browsers that runs the
applet for you.
Figure 1.2.
Traditional compiled
programs.
Your Code
Compiler (Pentium)
Binary File
(Pentium)
Binary File
(PowerPC)
Binary File
(SPARC)
Compiler (PowerPC)
Compiler (SPARC)
Figure 1.3.
Java programs.
Java Code
Java Compiler
(Pentium)
Java Bytecode
(Platform-
Independent)
Java Compiler
(PowerPC)
Java Compiler
(SPARC)
Java Interpreter
(Pentium)
Java Interpreter
(PowerPC)
Java Interpreter
(SPARC)
Window
Window
Window
030-4s CH01.i
1/29/96, 8:35 PM
8
9
Sams.netLearningCenterabcd
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
Why go through all the trouble of adding this extra layer of the bytecode interpreter? Having
your Java programs in bytecode form means that instead of being specific to any one system, your
programs can be run on any platform and any operating or window system as long as the Java
interpreter is available. This capability of a single binary file to be executable across platforms
is crucial to what enables applets to work, because the World Wide Web itself is also platform-
independent. Just as HTML files can be read on any platform, so applets can be executed on any
platform that is a Java-capable browser.
The disadvantage of using bytecodes is in execution speed. Because system-specific programs
run directly on the hardware for which they are compiled, they run significantly faster than Java
bytecodes, which must be processed by the interpreter. For many Java programs, the speed may
not be an issue. If you write programs that require more execution speed than the Java interpreter
can provide, you have several solutions available to you, including being able to link native code
into your Java program or using tools to convert your Java bytecodes into native code. Note that
by using any of these solutions, you lose the portability that Java bytecodes provide. You’ll learn
about each of these mechanisms on Day 20.
Java Is Object-Oriented
To some, object-oriented programming (OOP) technique is merely a way of organizing
programs, and it can be accomplished using any language. Working with a real object-oriented
language and programming environment, however, enables you to take full advantage of object-
oriented methodology and its capabilities of creating flexible, modular programs and reusing
code.
Many of Java’s object-oriented concepts are inherited from C++, the language on which it is
based, but it borrows many concepts from other object-oriented languages as well. Like most
object-oriented programming languages, Java includes a set of class libraries that provide basic
data types, system input and output capabilities, and other utility functions. These basic classes
are part of the Java development kit, which also has classes to support networking, common
Internet protocols, and user interface toolkit functions. Because these class libraries are written
in Java, they are portable across platforms as all Java applications are.
You’ll learn more about object-oriented programming and Java tomorrow.
Java Is Easy to Learn
In addition to its portability and object-orientation, one of Java’s initial design goals was to be
small and simple, and therefore easier to write, easier to compile, easier to debug, and, best of
all, easy to learn. Keeping the language small also makes it more robust because there are fewer
chances for programmers to make difficult-to-find mistakes. Despite its size and simple design,
however, Java still has a great deal of power and flexibility.
030-4s CH01.i
1/29/96, 8:35 PM
9
10
An Introduction to Java Programming
M
T W
R
F
S
S
DAY
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
Java is modeled after C and C++, and much of the syntax and object-oriented structure is
borrowed from the latter. If you are familiar with C++, learning Java will be particularly easy for
you, because you have most of the foundation already.
Although Java looks similar to C and C++, most of the more complex parts of those languages
have been excluded from Java, making the language simpler without sacrificing much of its
power. There are no pointers in Java, nor is there pointer arithmetic. Strings and arrays are real
objects in Java. Memory management is automatic. To an experienced programmer, these
omissions may be difficult to get used to, but to beginners or programmers who have worked
in other languages, they make the Java language far easier to learn.
Getting Started with
Programming in Java
Enough background! Let’s finish off this day by creating two real Java programs: a stand-alone
Java application and an applet that you can view in either in the appletviewer (part of the JDK)
or in a Java-capable browser. Although both these programs are extremely simple, they will give
you an idea of what a Java program looks like and how to compile and run it.
Getting the Software
In order to write Java programs, you will, of course, need a Java development environment. At
the time this book is being written, Sun’s Java Development Kit provides everything you need
to start writing Java programs. The JDK is available for Sun SPARC systems running Solaris 2.2
or higher and for Windows NT and Windows 95. You can get the JDK from several places:
■ The CD-ROM that came with this book contains the full JDK distribution. See the
CD information for installation instructions.
■ The JDK can be downloaded from Sun’s Java FTP site at ftp://java.sun.com/pub/ or
from a mirror site (ftp://www.blackdown.org/pub/Java/pub/is one).
Note: The Java Development Kit is currently in beta release. By the time you read
this, The JDK may be available for other platforms, or other organizations may be
selling Java development tools as well.
Although Netscape and other Java-aware browsers provide an environment for playing Java
applets, they do not provide a mechanism for developing Java applications. For that, you need
separate tools—merely having a browser is not enough.
030-4s CH01.i
1/29/96, 8:35 PM
10
11
Sams.netLearningCenterabcd
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
Applets and Applications
Java applications fall into two main groups: applets and applications.
Applets, as you have learned, are Java programs that are downloaded over the World Wide Web
and executed by a Web browser on the reader’s machine. Applets depend on a Java-capable
browser in order to run (although they can also be viewed using a tool called the appletviewer,
which you’ll learn about later today).
Java applications are more general programs written in the Java language. Java applications don’t
require a browser to run, and in fact, Java can be used to create most other kinds of applications
that you would normally use a more conventional programming language to create. HotJava
itself is a Java application.
A single Java program can be an applet or an application or both, depending on how you write
that program and the capabilities that program uses. Throughout this first week, you’ll be
writing mostly HotJava applications; then you’ll apply what you’ve learned to write applets in
Week 2. If you’re eager to get started with applets, be patient. Everything that you learn while
you’re creating simple Java applications will apply to creating applets, and it’s easier to start with
the basics before moving onto the hard stuff. You’ll be creating plenty of applets in Week 2.
Creating a Java Application
Let’s start by creating a simple Java application: the classic Hello World example that all language
books use to begin.
As with all programming languages, your Java source files are created in a plain text editor, or
in an editor that can save files in plain ASCII without any formatting characters. On Unix,
emacs, ped, or vi will work; on Windows, Notepad or DOS Edit are both text editors.
Fire up your editor of choice, and enter the Java program shown in Listing 1.1. Type this
program, as shown, in your text editor. Be careful that all the parentheses, braces, and quotes
are there.
Listing 1.1. Your first Java application.
1: class HelloWorld {
2: public static void main (String args[]) {
3: System.out.println(“Hello World!”);
4: }
5: }
Type
030-4s CH01.i
1/29/96, 8:35 PM
11
12
An Introduction to Java Programming
M
T W
R
F
S
S
DAY
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
!! Warning: The numbers before each line are part of the listing and not part of the
program; they’re there so I can refer to specific line numbers when I explain what’s
going on in the program. Do not include them in your own file.
This program has two main parts:
■ All the program is enclosed in a class definition—here, a class called HelloWorld.
■ The body of the program (here, just the one line) is contained in a routine called
main(). In Java applications, as in a C or C++ program, main() is the first
routine that is run when the program is executed.
You’ll learn more about both these parts of a Java application as the book progresses.
Once you finish typing the program, save the file. Conventionally, Java source files are named
the same name as the class they define, with an extension of .java. This file should therefore be
called HelloWorld.java.
Now, let’s compile the source file using the Java compiler. In Sun’s JDK, the Java compiler is
called javac.
To compile your Java program, Make sure the javac program is in your execution path and type
javac followed by the name of your source file:
javac HelloWorld.java
Note: In these examples, and in all the examples throughout this book, we’ll be
using Sun’s Java compiler, part of the JDK. If you have a third-party development
environment, check with the documentation for that program to see how to
compile your Java programs.
The compiler should compile the file without any errors. If you get errors, go back and make
sure that you’ve typed the program exactly as it appears in Listing 1.1.
When the program compiles without errors, you end up with a file called HelloWorld.class, in
the same directory as your source file. This is your Java bytecode file. You can then run that
bytecode file using the Java interpreter. In the JDK, the Java interpreter is called simply java.
Make sure the java program is in your path and type java followed by the name of the file without
the .class extension:
java HelloWorld
Analysis
030-4s CH01.i
1/29/96, 8:35 PM
12
13
Sams.netLearningCenterabcd
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
If your program was typed and compiled correctly, you should get the string “Hello World!”
printed to your screen as a response.
Note: Remember, the Java compiler and the Java interpreter are different things.
You use the Java compiler (javac) for your Java source files to create .class files, and
you use the Java interpreter (java)to actually run your class files.
Creating a Java Applet
Creating applets is different from creating a simple application, because Java applets run and are
displayed inside a Web page with other page elements and as such have special rules for how they
behave. Because of these special rules for applets in many cases (particularly the simple ones),
creating an applet may be more complex than creating an application.
For example, to do a simple Hello World applet, instead of merely being able to print a message,
you have to create an applet to make space for your message and then use graphics operations
to paint the message to the screen.
Note: Actually, if you run the Hello World application as an applet, the Hello
World message prints to a special window or to a log file, depending on how the
browser has screen messages set up. It will not appear on the screen unless you
write your applet to put it there.
In the next example, you create that simple Hello World applet, place it inside a Web page, and
view the result.
First, you set up an environment so that your Java-capable browser can find your HTML files
and your applets. Much of the time, you’ll keep your HTML files and your applet code in the
same directory. Although this isn’t required, it makes it easier to keep track of each element. In
this example, you use a directory called HTML that contains all the files you’ll need.
mkdir HTML
Now, open up that text editor and enter Listing 1.2.
030-4s CH01.i
1/29/96, 8:36 PM
13
14
An Introduction to Java Programming
M
T W
R
F
S
S
DAY
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
Listing 1.2. The Hello World applet.
1: import java.awt.Graphics;
2:
3: class HelloWorldApplet extends java.applet.Applet {
4:
5: public void paint(Graphics g) {
6: g.drawString(“Hello world!”, 5, 25);
7: }
8:}
Save that file inside your HTML directory. Just like with Java applications, give your file a name
that has the same name as the class. In this case, the filename would be HelloWorldApplet.java.
Features to note about applets? There are a couple I’d like to point out:
■ The import line at the top of the file is somewhat analogous to an #include statement
in C; it enables this applet to interact with the JDK classes for creating applets and for
drawing graphics on the screen.
■ The paint() method displays the content of the applet onto the screen. Here, the
string Hello World gets drawn. Applets use several standard methods to take the place
of main(), which include init() to initialize the applet, start() to start it running,
and paint() to display it to the screen. You’ll learn about all of these in Week 2.
Now, compile the applet just as you did the application, using javac, the Java compiler.
javac HelloWorldApplet.java
Again, just as for applications, you should now have a file called HelloWorldApplet.class in your
HTML directory.
To include an applet in a Web page, you refer to that applet in the HTML code for that Web
page. Here, you create a very simple HTML file in the HTML directory (see Listing 1.3).
Listing 1.3. The HTML with the applet in it.
1:
2:
3:
4:
5:

My Java applet says:
6:
7:
8:
Type
Type
030-4s CH01.i
1/29/96, 8:36 PM
14
15
Sams.netLearningCenterabcd
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
You refer to an applet in your HTML files with the tag. You’ll learn more about
later on, but here are two things to note:
■ Use the CODE attribute to indicate the name of the class that contains your applet.
■ Use the WIDTH and HEIGHT attributes to indicate the size of the applet. The browser uses
these values to know how big a chunk of space to leave for the applet on the page.
Here, a box 150 pixels wide and 25 pixels high is created.
Save the HTML file in your HTML directory, with a descriptive name (for example, you might
name your HTML file the same name as your applet—HellowWorldApplet.html).
And now, you’re ready for the final test—actually viewing the result of your applet. To view the
applet, you need one of the following:
■ A browser that supports Java applets, such as Netscape 2.0.
■ The appletviewer application, which is part of the JDK. The appletviewer is not a
Web browser and won’t enable you to see the entire Web page, but it’s acceptable for
testing to see how an applet will look and behave if there is nothing else available.
Note: Do not use the alpha version of HotJava to view your applets; applets
developed with the beta JDK and onward cannot be viewed by the alpha HotJava.
If, by the time you read this, there is a more recent version of HotJava, you can use
that one instead.
If you’re using a Java-capable browser such as Netscape to view your applet files, you can use the
Open Local... item under the File menu to navigate to the HTML file containing the applet
(make sure you open the HTML file and not the class file). You don’t need to install anything
on a Web server yet; all this works on your local system.
If you don’t have a Web browser with Java capabilities built into it, you can use the appletviewer
program to view your Java applet. To run appletviewer, just indicate the path to the HTML file
on the command line:
appletviewer HTML/HelloWorldApplet.html
Tip: Although you can start appletviewer from the same directory as your HTML
and class files, you may not be able to reload that applet without quitting
appletviewer first. If you start appletviewer from some other directory (as in the
previous command line), you can modify and recompile your Java applets and then
just use the Reload menu item to view the newer version.
Analysis
030-4s CH01.i
1/29/96, 8:36 PM
15
16
An Introduction to Java Programming
M
T W
R
F
S
S
DAY
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
Now, if you use the browser to view the applet, you see something similar to the image shown
in Figure 1.4. If you’re using appletviewer, you won’t see the text around the applet (My Java
applet says...), but you will see the Hello World itself.
Figure 1.4.
The Hello World applet.
Summary
Today, you got a basic introduction to the Java language and its goals and features. Java is a
programming language, similar to C or C++, in which you can develop a wide range of programs.
The most common use of Java at the moment is in creating applets for HotJava, an advanced
World Wide Web browser also written in Java. Applets are Java programs that are downloaded
and run as part of a Web page. Applets can create animations, games, interactive programs, and
other multimedia effects on Web pages.
Java’s strengths lie in its portability—both at the source and at the binary level, in its object-
oriented design—and in its simplicity. Each of these features help make applets possible, but
they also make Java an excellent language for writing more general-purpose programs that do
not require HotJava or other Java-capable browser to run. These general-purpose Java programs
are called applications. HotJava itself is a Java application.
To end this day, you experimented with an example applet and an example application, getting
a feel for the differences between the two and how to create, compile, and run Java programs—
or, in the case of applets, how to include them in Web pages. From here, you now have the
foundation to create more complex applications and applets.
Q&A
Q I’d like to use HotJava as my regular Web browser. You haven’t mentioned much
about HotJava today.
A The focus of this book is primarily on programming in Java and in the HotJava
classes, rather than on using HotJava itself. Documentation for using the HotJava
browser comes with the HotJava package.
Q I know a lot about HTML, but not much about computer programming. Can I
still write Java programs?
030-4s CH01.i
1/29/96, 8:36 PM
16
17
Sams.netLearningCenterabcd
1
P2/V4sqc7 TY Java in 21 Days 030-4 sdv 12.22.95 Ch01 LP#4
A If you have no programming experience whatsoever, you most likely will find pro-
gramming Java significantly more difficult. However, Java is an excellent language to
learn programming with, and if you patiently work through the examples and the
exercises in this book, you should be able to learn enough to get started with Java.
Q According to today’s lesson, Java applets are downloaded via HotJava and run on
the reader’s system. Isn’t that an enormous security hole? What stops someone
from writing an applet that compromises the security of my system—or worse,
that damages my system?
A Sun’s Java team has thought a great deal about the security of applets within Java-
capable browsers and has implemented several checks to make sure applets cannot do
nasty things:
■ Java applets cannot read or write to the disk on the local system.
■ Java applets cannot execute any programs on the local system.
■ Java applets cannot connect to any machines on the Web except for the server
from which they are originally downloaded.
In addition, the Java compiler and interpreter check both the Java source code and the
Java bytecodes to make sure that the Java programmer has not tried any sneaky tricks
(for example, overrunning buffers or stack frames).
These checks obviously cannot stop every potential security hole, but they can
significantly reduce the potential for hostile applets. You’ll learn more about security
issues later on in this book.
Q I followed all the directions you gave for creating a Java applet. I loaded it into
HotJava, but Hello World didn’t show up. What did I do wrong?
A I’ll bet you’re using the alpha version of HotJava to view the applet. Unfortunately,
between alpha and beta, significant changes were made as to how applets are written.
The result is that you can’t view beta applets (as this one was) in the alpha version of
HotJava, nor can you view alpha applets in browsers that expect beta applets. To view
the applet, either use a different browser, or use the appletviewer application that
comes with the JDK.
030-4s CH01.i
1/29/96, 8:36 PM
17
19
Sams.netLearningCenterabcd
P2/V4sqc6 TY Java in 21 Days 030-4 ayanna 12.15.95 Ch02 LP#3
2
M
T W
R
F
S
S
Object-Oriented
Programming
and Java
by Laura Lemay
WEEK
1
2
030-4S CH02.i
1/29/96, 8:37 PM
19
20
Object-Oriented Programming and Java
M
T W
R
F
S
S
DAY
2
P2/V4sqc6 TY Java in 21 Days 030-4 ayanna 12.15.95 Ch02 LP#3
Object-oriented programming (OOP) is one of the bigger programming buzzwords of recent
years, and you can spend years learning all about object-oriented programming methodologies
and how they can make your life easier than The Old Way of programming. It all comes down
to organizing your programs in ways that echo how things are put together in the real world.
Today, you’ll get an overview of object-oriented programming concepts in Java and how they
relate to how you structure your own programs:
■ What classes and objects are, and how they relate to each other
■ The two main parts of a class or object: its behaviors and its attributes
■ Class inheritance and how inheritance affects the way you design your programs
■ Some information about packages and interfaces
If you’re already familiar with object-oriented programming, much of today’s lesson will be old
hat to you. You may want to skim it and go to a movie today instead. Tomorrow, you’ll get into
more specific details.
Thinking in Objects: An Analogy
Consider, if you will, Legos. Legos, for those who do not spend much time with children, are
small plastic building blocks in various colors and sizes. They have small round bits on one side
that fit into small round holes on other Legos so that they fit together snugly to create larger
shapes. With different Lego bits (Lego wheels, Lego engines, Lego hinges, Lego pulleys), you can
put together castles, automobiles, giant robots that swallow cities, or just about anything else you
can create. Each Lego bit is a small object that fits together with other small objects in predefined
ways to create other larger objects.
Here’s another example. You can walk into a computer store and, with a little background and
often some help, assemble an entire PC computer system from various components: a
motherboard, a CPU chip, a video card, a hard disk, a keyboard, and so on. Ideally, when you
finish assembling all the various self-contained units, you have a system in which all the units
work together to create a larger system with which you can solve the problems you bought the
computer for in the first place.
Internally, each of those components may be vastly complicated and engineered by different
companies with different methods of design. But you don’t need to know how the component
works, what every chip on the board does, or how, when you press the A key, an “A” gets sent
to your computer. As the assembler of the overall system, each component you use is a self-
contained unit, and all you are interested in is how the units interact with each other. Will this
video card fit into the slots on the motherboard and will this monitor work with this video card?
Will each particular component speak the right commands to the other components it interacts
with so that each part of the computer is understood by every other part? Once you know what
030-4S CH02.i
1/29/96, 8:37 PM
20
21
Sams.netLearningCenterabcd
P2/V4sqc6 TY Java in 21 Days 030-4 ayanna 12.15.95 Ch02 LP#3
2
the interactions are between the components and can match the interactions, putting together
the overall system is easy.
What does this have to do with programming? Everything. Object-oriented programming
works in exactly this same way. Using object-oriented programming, your overall program is
made up of lots of different self-contained components (objects), each of which has a specific
role in the program and all of which can talk to each other in predefined ways.
Objects and Classes
Object-oriented programming is modeled on how, in the real world, objects are often made up
of many kinds of smaller objects. This capability of combining objects, however, is only one very
general aspect of object-oriented programming. Object-oriented programming provides several
other concepts and features to make creating and using objects easier and more flexible, and the
most important of these features is that of classes.
A class is a template for multiple objects with similar features. Classes embody all the
features of a particular set of objects.
When you write a program in an object-oriented language, you don’t define actual objects. You
define classes of objects.
For example, you might have a Tree class that describes the features of all trees (has leaves and
roots, grows, creates chlorophyll). The Tree class serves as an abstract model for the concept of
a tree—to reach out and grab, or interact with, or cut down a tree you have to have a concrete
instance of that tree. Of course, once you have a tree class, you can create lots of different
instances of that tree, and each different tree instance can have different features (short, tall,
bushy, drops leaves in Autumn), while still behaving like and being immediately recognizable
as a tree (see Figure 2.1).
An instance of a class is another word for an actual object. If classes are an abstract
representation of an object, an instance is its concrete representation.
So what, precisely, is the difference between an instance and an object? Nothing, really. Object
is the more general term, but both instances and objects are the concrete representation of a class.
In fact, the terms instance and object are often used interchangeably in OOP language. An
instance of a tree and a tree object are both the same thing.
In an example closer to the sort of things you might want to do in Java programming, you might
create a class for the user interface element called a button. The Button class defines the features
of a button (its label, its size, its appearance) and how it behaves (does it need a single click or
a double click to activate it, does it change color when it’s clicked, what does it do when it’s
activated?). Once you define the Button class, you can then easily create instances of that
button—that is, button objects—that all take on the basic features of the button as defined by
NEW
TERM
☛
NEW
TERM
☛
030-4S CH02.i
1/29/96, 8:37 PM
21