14 CHAPTER 1.

THE MENTAL LANDSCAPE

J C o m p o n e n t

J L a b e l J A b s t r a c t B u t t o n J C o m b o B o x J S c r o l l b a r J T e x t C o m p o n e n t

J B u t t o n J T o g g l e B u t t o n J T e x t F i e l d J T e x t A r e a

J C h e c k B o x J R a d i o B u t t o n

Don’t worry about the details for now, but try to get some feel about how object-oriented
programming and inheritance are used here. Note that all the GUI classes are subclasses,
directly or indirectly, of a class called JComponent, which represents general properties that are
shared by all Swing components. Two of the direct subclasses of JComponent themselves have
subclasses. The classes JTextArea and JTextField, which have certain behaviors in common,
are grouped together as subclasses of JTextComponent. Similarly JButton and JToggleButton
are subclasses of JAbstractButton, which represents properties common to both buttons and
checkboxes. (JComboBox, by the way, is the Swing class that represents pop-up menus.)
Just from this brief discussion, perhaps you can see how GUI programming can make effec-
tive use of object-oriented design. In fact, GUI’s, with their “visible objects,” are probably a
major factor contributing to the popularity of OOP.
Programming with GUI components and events is one of the most interesting aspects of
Java. However, we will spend several chapters on the basics before returning to this topic in
Chapter 6.

1.7 The Internet and the World-Wide Web

Computers can be connected together on networks. A computer on a network can
communicate with other computers on the same network by exchanging data and files or by
sending and receiving messages. Computers on a network can even work together on a large
computation.
Today, millions of computers throughout the world are connected to a single huge network
called the Internet. New computers are being connected to the Internet every day. Computers
can join the Internet by using a modem to establish a connection through telephone lines.
Broadband connections to the Internet, such as DSL and cable modems, are increasingly
common. They allow faster data transmission than is possible through telephone modems.
There are elaborate protocols for communication over the Internet. A protocol is simply a
detailed specification of how communication is to proceed. For two computers to communicate
at all, they must both be using the same protocols. The most basic protocols on the Internet are
the Internet Protocol (IP), which specifies how data is to be physically transmitted from one
computer to another, and the Transmission Control Protocol (TCP), which ensures that
data sent using IP is received in its entirety and without error. These two protocols, which are
referred to collectively as TCP/IP, provide a foundation for communication. Other protocols
1.7. THE INTERNET 15

use TCP/IP to send specific types of information such as web pages, electronic mail, and data
files.
All communication over the Internet is in the form of packets. A packet consists of some
data being sent from one computer to another, along with addressing information that indicates
where on the Internet that data is supposed to go. Think of a packet as an envelope with an
address on the outside and a message on the inside. (The message is the data.) The packet
also includes a “return address,” that is, the address of the sender. A packet can hold only
a limited amount of data; longer messages must be divided among several packets, which are
then sent individually over the net and reassembled at their destination.
Every computer on the Internet has an IP address, a number that identifies it uniquely
among all the computers on the net. The IP address is used for addressing packets. A computer
can only send data to another computer on the Internet if it knows that computer’s IP address.
Since people prefer to use names rather than numbers, most computers are also identified by
names, called domain names. For example, the main computer of the Mathematics Depart-
ment at Hobart and William Smith Colleges has the domain name math.hws.edu. (Domain
names are just for convenience; your computer still needs to know IP addresses before it can
communicate. There are computers on the Internet whose job it is to translate domain names
to IP addresses. When you use a domain name, your computer sends a message to a domain
name server to find out the corresponding IP address. Then, your computer uses the IP address,
rather than the domain name, to communicate with the other computer.)
The Internet provides a number of services to the computers connected to it (and, of course,
to the users of those computers). These services use TCP/IP to send various types of data over
the net. Among the most popular services are instant messaging, file sharing, electronic mail,
and the World-Wide Web. Each service has its own protocols, which are used to control
transmission of data over the network. Each service also has some sort of user interface, which
allows the user to view, send, and receive data through the service.
For example, the email service uses a protocol known as SMTP (Simple Mail Transfer
Protocol) to transfer email messages from one computer to another. Other protocols, such as
POP and IMAP, are used to fetch messages from an email account so that the recipient can
read them. A person who uses email, however, doesn’t need to understand or even know about
these protocols. Instead, they are used behind the scenes by the programs that the person uses
to send and receive email messages. These programs provide an easy-to-use user interface to
the underlying network protocols.
The World-Wide Web is perhaps the most exciting of network services. The World-Wide
Web allows you to request pages of information that are stored on computers all over the
Internet. A Web page can contain links to other pages on the same computer from which it
was obtained or to other computers anywhere in the world. A computer that stores such pages
of information is called a web server . The user interface to the Web is the type of program
known as a web browser . Common web browsers include Internet Explorer and Firefox. You
use a Web browser to request a page of information. The browser will send a request for that
page to the computer on which the page is stored, and when a response is received from that
computer, the web browser displays it to you in a neatly formatted form. A web browser is just
a user interface to the Web. Behind the scenes, the web browser uses a protocol called HTTP
(HyperText Transfer Protocol) to send each page request and to receive the response from the
web server.
∗ ∗ ∗
Now just what, you might be thinking, does all this have to do with Java? In fact, Java
16 CHAPTER 1. THE MENTAL LANDSCAPE

is intimately associated with the Internet and the World-Wide Web. As you have seen in the
previous section, special Java programs called applets are meant to be transmitted over the
Internet and displayed on Web pages. A Web server transmits a Java applet just as it would
transmit any other type of information. A Web browser that understands Java—that is, that
includes an interpreter for the Java virtual machine—can then run the applet right on the Web
page. Since applets are programs, they can do almost anything, including complex interaction
with the user. With Java, a Web page becomes more than just a passive display of information.
It becomes anything that programmers can imagine and implement.
But applets are only one aspect of Java’s relationship with the Internet, and not the major
one. In fact, as both Java and the Internet have matured, applets have become less important.
At the same time, however, Java has increasingly been used to write complex, stand-alone
applications that do not depend on a web browser. Many of these programs are network-
related. For example many of the largest and most complex web sites use web server software
that is written in Java. Java includes excellent support for network protocols, and its platform
independence makes it possible to write network programs that work on many different types
of computer.
Its association with the Internet is not Java’s only advantage. But many good programming
languages have been invented only to be soon forgotten. Java has had the good luck to ride on
the coattails of the Internet’s immense and increasing popularity.
Quiz 17

Quiz on Chapter 1

1. One of the components of a computer is its CPU. What is a CPU and what role does it
play in a computer?

2. Explain what is meant by an “asynchronous event.” Give some examples.

3. What is the difference between a “compiler” and an “interpreter”?

4. Explain the difference between high-level languages and machine language.

5. If you have the source code for a Java program, and you want to run that program, you
will need both a compiler and an interpreter. What does the Java compiler do, and what
does the Java interpreter do?

6. What is a subroutine?

7. Java is an object-oriented programming language. What is an object?

8. What is a variable? (There are four different ideas associated with variables in Java. Try
to mention all four aspects in your answer. Hint: One of the aspects is the variable’s
name.)

9. Java is a “platform-independent language.” What does this mean?

10. What is the “Internet”? Give some examples of how it is used. (What kind of services
does it provide?)
18 CHAPTER 1. THE MENTAL LANDSCAPE
Chapter 2

Programming in the Small I:

Names and Things

On a basic level (the level of machine language), a computer can perform only very simple
operations. A computer performs complex tasks by stringing together large numbers of such
operations. Such tasks must be “scripted” in complete and perfect detail by programs. Creating
complex programs will never be really easy, but the difficulty can be handled to some extent by
giving the program a clear overall structure. The design of the overall structure of a program
is what I call “programming in the large.”
Programming in the small, which is sometimes called coding , would then refer to filling in
the details of that design. The details are the explicit, step-by-step instructions for performing
fairly small-scale tasks. When you do coding, you are working fairly “close to the machine,”
with some of the same concepts that you might use in machine language: memory locations,
arithmetic operations, loops and branches. In a high-level language such as Java, you get to
work with these concepts on a level several steps above machine language. However, you still
have to worry about getting all the details exactly right.
This chapter and the next examine the facilities for programming in the small in the Java
programming language. Don’t be misled by the term “programming in the small” into thinking
that this material is easy or unimportant. This material is an essential foundation for all types
of programming. If you don’t understand it, you can’t write programs, no matter how good
you get at designing their large-scale structure.

2.1 The Basic Java Application

A program is a sequence of instructions that a computer can execute to perform some
task. A simple enough idea, but for the computer to make any use of the instructions, they
must be written in a form that the computer can use. This means that programs have to be
written in programming languages. Programming languages differ from ordinary human
languages in being completely unambiguous and very strict about what is and is not allowed
in a program. The rules that determine what is allowed are called the syntax of the language.
Syntax rules specify the basic vocabulary of the language and how programs can be constructed
using things like loops, branches, and subroutines. A syntactically correct program is one that
can be successfully compiled or interpreted; programs that have syntax errors will be rejected
(hopefully with a useful error message that will help you fix the problem).
So, to be a successful programmer, you have to develop a detailed knowledge of the syntax

19
20 CHAPTER 2. NAMES AND THINGS

of the programming language that you are using. However, syntax is only part of the story. It’s
not enough to write a program that will run—you want a program that will run and produce
the correct result! That is, the meaning of the program has to be right. The meaning of a
program is referred to as its semantics. A semantically correct program is one that does what
you want it to.
Furthermore, a program can be syntactically and semantically correct but still be a pretty
bad program. Using the language correctly is not the same as using it well. For example, a
good program has “style.” It is written in a way that will make it easy for people to read and
to understand. It follows conventions that will be familiar to other programmers. And it has
an overall design that will make sense to human readers. The computer is completely oblivious
to such things, but to a human reader, they are paramount. These aspects of programming are
sometimes referred to as pragmatics.
When I introduce a new language feature, I will explain the syntax, the semantics, and
some of the pragmatics of that feature. You should memorize the syntax; that’s the easy part.
Then you should get a feeling for the semantics by following the examples given, making sure
that you understand how they work, and maybe writing short programs of your own to test
your understanding. And you should try to appreciate and absorb the pragmatics—this means
learning how to use the language feature well, with style that will earn you the admiration of
other programmers.
Of course, even when you’ve become familiar with all the individual features of the language,
that doesn’t make you a programmer. You still have to learn how to construct complex programs
to solve particular problems. For that, you’ll need both experience and taste. You’ll find hints
about software development throughout this textbook.
∗ ∗ ∗
We begin our exploration of Java with the problem that has become traditional for such
beginnings: to write a program that displays the message “Hello World!”. This might seem like
a trivial problem, but getting a computer to do this is really a big first step in learning a new
programming language (especially if it’s your first programming language). It means that you
understand the basic process of:
1. getting the program text into the computer,
2. compiling the program, and
3. running the compiled program.
The first time through, each of these steps will probably take you a few tries to get right. I
won’t go into the details here of how you do each of these steps; it depends on the particular
computer and Java programming environment that you are using. See Section 2.6 for informa-
tion about creating and running Java programs in specific programming environments. But in
general, you will type the program using some sort of text editor and save the program in a
file. Then, you will use some command to try to compile the file. You’ll either get a message
that the program contains syntax errors, or you’ll get a compiled version of the program. In
the case of Java, the program is compiled into Java bytecode, not into machine language. Fi-
nally, you can run the compiled program by giving some appropriate command. For Java, you
will actually use an interpreter to execute the Java bytecode. Your programming environment
might automate some of the steps for you, but you can be sure that the same three steps are
being done in the background.
Here is a Java program to display the message “Hello World!”. Don’t expect to understand
what’s going on here just yet—some of it you won’t really understand until a few chapters from
2.1. THE BASIC JAVA APPLICATION 21

now:
// A program to display the message
// "Hello World!" on standard output
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
} // end of class HelloWorld

The command that actually displays the message is:

System.out.println("Hello World!");

This command is an example of a subroutine call statement. It uses a “built-in subroutine”

named System.out.println to do the actual work. Recall that a subroutine consists of the
instructions for performing some task, chunked together and given a name. That name can be
used to “call” the subroutine whenever that task needs to be performed. A built-in subroutine
is one that is already defined as part of the language and therefore automatically available for
use in any program.
When you run this program, the message “Hello World!” (without the quotes) will be
displayed on standard output. Unfortunately, I can’t say exactly what that means! Java is
meant to run on many different platforms, and standard output will mean different things on
different platforms. However, you can expect the message to show up in some convenient place.
(If you use a command-line interface, like that in Sun Microsystem’s Java Development Kit,
you type in a command to tell the computer to run the program. The computer will type the
output from the program, Hello World!, on the next line.)
You must be curious about all the other stuff in the above program. Part of it consists of
comments. Comments in a program are entirely ignored by the computer; they are there for
human readers only. This doesn’t mean that they are unimportant. Programs are meant to be
read by people as well as by computers, and without comments, a program can be very difficult
to understand. Java has two types of comments. The first type, used in the above program,
begins with // and extends to the end of a line. The computer ignores the // and everything
that follows it on the same line. Java has another style of comment that can extend over many
lines. That type of comment begins with /* and ends with */.
Everything else in the program is required by the rules of Java syntax. All programming in
Java is done inside “classes.” The first line in the above program (not counting the comments)
says that this is a class named HelloWorld. “HelloWorld,” the name of the class, also serves as
the name of the program. Not every class is a program. In order to define a program, a class
must include a subroutine named main, with a definition that takes the form:
public static void main(String[] args) {
hstatements i
}

When you tell the Java interpreter to run the program, the interpreter calls the main()
subroutine, and the statements that it contains are executed. These statements make up the
script that tells the computer exactly what to do when the program is executed. The main()
routine can call subroutines that are defined in the same class or even in other classes, but it is
the main() routine that determines how and in what order the other subroutines are used.
22 CHAPTER 2. NAMES AND THINGS

The word “public” in the first line of main() means that this routine can be called from out-
side the program. This is essential because the main() routine is called by the Java interpreter,
which is something external to the program itself. The remainder of the first line of the routine
is harder to explain at the moment; for now, just think of it as part of the required syntax.
The definition of the subroutine—that is, the instructions that say what it does—consists of
the sequence of “statements” enclosed between braces, { and }. Here, I’ve used hstatementsi as
a placeholder for the actual statements that make up the program. Throughout this textbook,
I will always use a similar format: anything that you see in hthis style of texti (italic in angle
brackets) is a placeholder that describes something you need to type when you write an actual
program.
As noted above, a subroutine can’t exist by itself. It has to be part of a “class”. A program
is defined by a public class that takes the form:
public class hprogram-name i {
hoptional-variable-declarations-and-subroutines i
public static void main(String[] args) {
hstatements i
}
hoptional-variable-declarations-and-subroutines i
}
The name on the first line is the name of the program, as well as the name of the class. If the
name of the class is HelloWorld, then the class must be saved in a file called HelloWorld.java.
When this file is compiled, another file named HelloWorld.class will be produced. This class
file, HelloWorld.class, contains the Java bytecode that is executed by a Java interpreter.
HelloWorld.java is called the source code for the program. To execute the program, you
only need the compiled class file, not the source code.
The layout of the program on the page, such as the use of blank lines and indentation, is
not part of the syntax or semantics of the language. The computer doesn’t care about layout—
you could run the entire program together on one line as far as it is concerned. However,
layout is important to human readers, and there are certain style guidelines for layout that are
followed by most programmers. These style guidelines are part of the pragmatics of the Java
programming language.
Also note that according to the above syntax specification, a program can contain other
subroutines besides main(), as well as things called “variable declarations.” You’ll learn more
about these later, but not until Chapter 4.

2.2 Variables and the Primitive Types

Names are fundamental to programming. In programs, names are used to refer to many
different sorts of things. In order to use those things, a programmer must understand the rules
for giving names to things and the rules for using the names to work with those things. That
is, the programmer must understand the syntax and the semantics of names.
According to the syntax rules of Java, a name is a sequence of one or more characters. It must
begin with a letter or underscore and must consist entirely of letters, digits, and underscores.
(“Underscore” refers to the character ’ ’.) For example, here are some legal names:
N n rate x15 quite a long name HelloWorld
2.2. VARIABLES AND TYPES 23

No spaces are allowed in identifiers; HelloWorld is a legal identifier, but “Hello World” is
not. Upper case and lower case letters are considered to be different, so that HelloWorld,
helloworld, HELLOWORLD, and hElloWorLD are all distinct names. Certain names are reserved
for special uses in Java, and cannot be used by the programmer for other purposes. These
reserved words include: class, public, static, if, else, while, and several dozen other
words.
Java is actually pretty liberal about what counts as a letter or a digit. Java uses the
Unicode character set, which includes thousands of characters from many different languages
and different alphabets, and many of these characters count as letters or digits. However, I will
be sticking to what can be typed on a regular English keyboard.
The pragmatics of naming includes style guidelines about how to choose names for things.
For example, it is customary for names of classes to begin with upper case letters, while names
of variables and of subroutines begin with lower case letters; you can avoid a lot of confusion
by following the same convention in your own programs. Most Java programmers do not use
underscores in names, although some do use them at the beginning of the names of certain kinds
of variables. When a name is made up of several words, such as HelloWorld or interestRate,
it is customary to capitalize each word, except possibly the first; this is sometimes referred
to as camel case, since the upper case letters in the middle of a name are supposed to look
something like the humps on a camel’s back.
Finally, I’ll note that things are often referred to by compound names which consist
of several ordinary names separated by periods. (Compound names are also called qualified
names.) You’ve already seen an example: System.out.println. The idea here is that things
in Java can contain other things. A compound name is a kind of path to an item through one
or more levels of containment. The name System.out.println indicates that something called
“System” contains something called “out” which in turn contains something called “println”.
Non-compound names are called simple identifiers. I’ll use the term identifier to refer to
any name—simple or compound—that can be used to refer to something in Java. (Note that
the reserved words are not identifiers, since they can’t be used as names for things.)

2.2.1 Variables
Programs manipulate data that are stored in memory. In machine language, data can only
be referred to by giving the numerical address of the location in memory where it is stored.
In a high-level language such as Java, names are used instead of numbers to refer to data. It
is the job of the computer to keep track of where in memory the data is actually stored; the
programmer only has to remember the name. A name used in this way—to refer to data stored
in memory—is called a variable.
Variables are actually rather subtle. Properly speaking, a variable is not a name for the
data itself but for a location in memory that can hold data. You should think of a variable as
a container or box where you can store data that you will need to use later. The variable refers
directly to the box and only indirectly to the data in the box. Since the data in the box can
change, a variable can refer to different data values at different times during the execution of
the program, but it always refers to the same box. Confusion can arise, especially for beginning
programmers, because when a variable is used in a program in certain ways, it refers to the
container, but when it is used in other ways, it refers to the data in the container. You’ll see
examples of both cases below.
(In this way, a variable is something like the title, “The President of the United States.”
This title can refer to different people at different times, but it always refers to the same office.