Section 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 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.
When I introduce a new language feature in these notes,
I will explain both the syntax and the semantics of that
feature. You should memorize the syntax; that's the easy
part. Then you should try to 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.
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:
- getting the program text into the computer,
- compiling the program, and
- running the compiled program.
The first time through, each of these steps will probably
take you a few tries to get right. I can't tell you 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 Appendix 2 for
information on some common Java 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. Finally, 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 now:
public class HelloWorld {
// A program to display the message
// "Hello World!" on standard output
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 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 called main, with a definition that takes the form:
public static void main(String[] args) {
statements
}
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.
The word "public" in the first line of main()
means that this routine can be
called from outside the program. This is essential because
the main() routine is called by the Java interpreter.
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 statements 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 this
style of text
(which is green
if your browser supports colored text) 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 program-name {
optional-variable-declarations-and-subroutines
public static void main(String[] args) {
statements
}
optional-variable-declarations-and-subroutines
}
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 should 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.
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 (starting with variables, in the
next section).
By the way, recall that one of the neat features of Java
is that it can be used to write applets that can run on pages
in a Web browser. Applets are very different things from stand-alone programs
such as the HelloWorld program,
and they are not written in the same way. For one thing, an
applet doesn't have a main() routine. Applets will
be covered in Chapter 6
and Chapter 7.
In the meantime, you will see applets in this text that
simulate stand-alone programs.
The applets you see are not really the same as the stand-alone
programs that they simulate,
since they run right on a Web page,
but they will have the same behavior as the programs I describe.
Here, just for fun, is an applet simulating the HelloWorld
program. To run the program, click on the button:
