Chapter 2—Programming by Example
The Art and Science of
An Introduction
to Computer Science
ERIC S. ROBERTS
Java
Programming by Example
C H A P T E R 2
Example is always more efficacious than precept.
—Samuel Johnson, Rasselas, 1759
CMPU-101
Computer Science I:
Problem-Solving and Abstraction
Fall 2008
Jennifer Walter
(adapted from slides by Eric Roberts)
The “Hello World” Program
One of the important influences on the
design of Java was the C programming
language, which was developed at Bell
Labs in the early 1970s. The primary
reference manual for C was written by
Brian Kernighan and Dennis Ritchie.
On the first page of their book, the
authors suggest that the first step in
learning any language is to write a
simple program that prints the message
“hello, world” on the display. That
advice remains sound today.
1.1 Getting Started
The only way to learn a new programming
language is to write programs in it. The first
program to write is the same for all languages:
Print the words
hello, world
This is the big hurdle; to leap over it you have to
be able to create the program text somewhere,
compile it, load it, run it, and find out where your
output went. With these mechanical details
mastered, everything else is comparatively easy.
In C, the program to print “hello, world” is
#include <stdio.h>
main() {
printf("hello, world");
}
The “Hello World” Program in Java
/*
* File: HelloProgram.java
* -----------------------
* This program displays "hello, world" on the screen.
* It is inspired by the first program in Brian
* Kernighan and Dennis Ritchie's classic book,
* The C Programming Language.
*/
import acm.graphics.*;
import acm.program.*;
public class HelloProgram extends GraphicsProgram {
public void run() {
add( new GLabel( "hello, world", 100, 75 ) );
}
}
/*
* File: HelloProgram.java
* -----------------------
* This program displays "hello, world" on the screen.
* It is inspired by the first program in Brian
* Kernighan and Dennis Ritchie's classic book,
* The C Programming Language.
*/
The simple “Hello World” example illustrates several features
that are common to the programs you will see in this book.
This first few lines (everything between /* and */) are an
example of a comment, which is intended for human readers.
import acm.graphics.*;
import acm.program.*;
public class HelloProgram extends GraphicsProgram {
public void run() {
add( new GLabel( "hello, world", 100, 75 ) );
}
}
The next two lines are the imports, which indicate what library
packages the program uses.
The last few lines in the file define the HelloProgram class,
which the extends keyword identifies as a GraphicsProgram.
A class definition in Java typically contains a series of entries.
This example has one entry, which is a method called run.
A Java method consists of a series of statements. Here, the only
statement is a call to add, which adds an object to the display.
The object to be added is indicated by supplying an argument to
the add method. Here, the argument is a new GLabel object.
In Java, objects are created by using a constructor, which consists
of the keyword new followed by the class name and arguments.
The arguments supply information that the constructor needs to
make the object, such as the string to display and the coordinates.
The next slide simulates the operation of HelloProgram so that
you can get a sense of what appears on the display.
/*
* File: HelloProgram.java
* -----------------------
* This program displays "hello, world" on the screen.
* It is inspired by the first program in Brian
* Kernighan and Dennis Ritchie's classic book,
* The C Programming Language.
*/
import acm.graphics.*;
import acm.program.*;
public class HelloProgram extends GraphicsProgram {
public void run() {
add( new GLabel( "hello, world", 100, 75 ) );
}
}
The “Hello World” Program in Java
import acm.graphics.*;
import acm.program.*;
public class HelloProgram extends GraphicsProgram {
public void run() {
add( new GLabel("hello, world", 100, 75) );
}
}
HelloProgram
hello, world
import acm.graphics.*;
import acm.program.*;
public class HelloProgram extends GraphicsProgram {
public void run() {
add( new GLabel("hello, world", 100, 75) );
}
}
Perspectives on the Programming Process
In his Pulitzer-prizewinning book, computer
scientist Douglas Hofstadter identifies two
concepts—holism and reductionism—that turn
out to be important as you begin to learn about
programming.
Hofstadter explains these concepts in the form of
a dialogue in the style of Lewis Carroll:
I will be glad to indulge both of you, if you will first oblige me, by telling me the
meaning of these strange expressions, “holism” and “reductionism”.
Achilles:
Crab: Holism is the most natural thing in the world to grasp. It’s simply the belief that
“the whole is greater than the sum of its parts”. No one in his right mind could
reject holism.
Anteater: Reductionism is the most natural thing in the world to grasp. It’s simply the belief
that “a whole can be understood completely if you understand its parts, and the
nature of their ‘sum’”. No one in her left brain could reject reductionism.
A Program to Add Two Numbers
import acm.program.*;
public class Add2Integers extends ConsoleProgram {
public void run() {
println("This program adds two numbers.");
int n1 = readInt("Enter n1: ");
int n2 = readInt("Enter n2: ");
int total = n1 + n2;
println("The total is " + total + ".");
}
}
The holistic perspective is particularly useful when you are first
learning to program. When you look at a program, you should
concentrate on understanding its operation in a general way
rather than focusing on the details. Consider, for example, the
following program, which adds two integers and prints their sum:
This program is an example of a ConsoleProgram, which reads
input from the keyboard and displays characters on the screen.
Such programs are not as exciting as graphical applications but
are useful for illustrating programming concepts.
As you saw in the case of the HelloProgram example, Java
programs written using the acm.program package begin by
executing the statements in the run method.
The first statement in the program prints a message to the user
describing what the program does.
The next two statements read the input values from the user, each
of which is a whole number, which is more formally called an
integer. The input values are stored in memory cells called
variables that serve as placeholders for those values.
The next statement computes the sum by adding the values stored
in the variables n1 and n2. In this statement, the + operator
represents addition, as in standard mathematics.
The final statement in the run method displays the result. In this
statement, the + operator signifies concatenation, which consists
of combining the operands together as strings.
The next slide animates the operation of this program to illustrate
the assignment of values to variables.
import acm.program.*;
public class Add2Integers extends ConsoleProgram {
public void run() {
println("This program adds two numbers.");
int n1 = readInt("Enter n1: ");
int n2 = readInt("Enter n2: ");
int total = n1 + n2;
println("The total is " + total + ".");
}
}
