Simple Java Applications

2.1 An Application and its Architecture

As we learned in the previous chapter, program construction follows the same methodology: We draw an initial design, the class diagram, and for each component (class) in the diagram, we write detailed instructions in Java, which are saved in a file in secondary storage. When we start the program, the class is copied into primary storage and becomes an executing object.

The Java designers use the term application to describe a program that is started by a human user. After an application's object is constructed in primary storage, a message is automatically sent to the application's main method, causing its instructions to execute. Therefore, every Java application must possess a method named main.

Begin Footnote: Not surprisingly, the precise explanation of how an application starts execution is more complex than what is stated here, but we nonetheless stick with our slogan that ``classes are copied into primary storage and become executing objects.'' End Footnote

To illustrate these ideas, we construct a small Java application that contains just the one method, main, which makes these two lines of text appear in the command window:

Hello to you!
49

FIGURE 1: architecture of initial application===========================



ENDFIGURE================================================================

The arrow in the diagram indicates that Hello sends messages to System.out. That is, it uses System.out by communicating with (or ``connecting to'') its println method.

Using terminology from Chapter 1, we say that Figure 1 presents an architecture where Hello is the controller (it controls what the program does) and System.out is the output view (it displays the ``view'' of the program to the human who uses it).

We write and place the instructions for class Hello in a file named Hello.java. Java instructions look like ``technical English,'' and the contents of Hello.java will look something like this:

public class Hello
{ public static void main(String[] args)
  {
    ... to be supplied momentarily ...
  }
}

For our example, main must contain instructions that display two full lines of text. The algorithm for this task goes:

1. Send a message to System.out to print "Hello to you!" on a line of its own in the command window.
2. Send a message to System.out to print the number 49 on a line of its own in the command window.

We must convert the above algorithm into Java instructions and insert them where the ellipses appeared above. Step 1 of the algorithm is written like this in Java:

System.out.println("Hello to you!");

System.out.println(49);

FIGURE 2: sample application============================================

/** Hello  prints two lines in the command window */
public class Hello 
{ public static void main(String[] args) 
  { System.out.println("Hello to you!");
    System.out.println(49); 
  }
}

ENDFIGURE============================================================

Before we dissect Figure 2 word by word, we demonstrate first how one types the program into the computer, checks the program's spelling and grammar, and starts it.

2.2 How to Build and Execute an Application

1. class Hello must be typed and saved in the file, Hello.java.
2. The program's spelling and grammar must be checked by the Java compiler; that is, the program must be compiled.
3. The program must be started (executed).

We briefly examine both options, and you should obtain help with selecting the one you will use. If you are not interested in this selection at this moment in time, you may skip either or both of the two subsections that follow.

2.2.1 Using an IDE

When an IDE is started, it will present a window into which you can type a Java application (or ``project,'' as the IDE might call it). Select the IDE's menu item or button named New Project to create a new project, and when the IDE asks, type the name of the class you wish to write. For the example in Figure 2, use the name, Hello, for the project:

Next, the program must be compiled. Compile by selecting the IDE's Compile or Build button:

Finally, start the program by selecting the button named Run or Launch (or Start, etc.) This starts the Java interpreter, which helps the processor read and execute the byte-code instructions in Hello.class. In the case of the Hello application, its execution causes two full lines of text to appear in the command window. The IDE shows the command window when needed:

(Footnote: Unfortunately, your IDE might show and remove the command window before you can read the text that appeared! If the command window disappears too quickly, insert these lines into your Java program immediately after the last System.out.println:

try { Thread.sleep(5000); }
catch (InterruptedException e) { }

2.2.2 Using the JDK

Once you have the JDK installed, the first step is to use a text editor to create the file, Hello.java, with the contents of Figure 2:

Next, compile the application by typing in a command window, javac Hello.java:

To execute the program, type the command, java Hello. This starts the program, more specifically, it starts the Java interpreter that helps the processor execute the byte-code instructions, and the two lines of text appear in the command window:

Details about error messages and error correction appear in a section later in this Chapter.

Exercise

2.3 How the Application Works

/** Hello  prints two lines in the command window */

You should begin every class you write with a comment that explains the class's purpose. Java programs are not all that easy for humans to read, and a few lines of explanation can prove very helpful!

Begin Footnote: By the way, it confuses the Java compiler if you place one comment inside another, e.g.

  /** A badly formed  /** comment */  looks like this. */

Following the comment is the line that gives the class's name, and then there are two matching brackets:

public class Hello
{
  ...
}

Words with special, specific meanings are called keywords. The keyword, public, indicates that the class can be used by the ``general public,'' which includes other objects and human users, to build objects on demand. The keyword, class, indicates of course that Hello is a Java class, the basic unit of program construction.

Following the program's header line is the program's body, which is enclosed by the matching brackets, { and }. Within the body lie the program's methods (as well as other items that we encounter in later chapters).

In the examples in this text, we will align the brackets vertically so that they are easy to see and match. The only exception to this rule will be when the brackets enclose a mere one-line body; then, the closing bracket will be placed at the end of the same line, to save space on the printed page. (See Figure 2 again.) When you type your own Java programs, you might prefer to use this style of bracket placement:

public class Hello {
 ...
}

Back to the example---Hello's body has but one method, main, which has its own header line and body:

public static void main(String[] args)
{
  ...
}

The body of the main method contains the instructions (statements) that will be executed when a Hello object is sent the message to execute its main method. These instructions are

System.out.println("Hello to you!");
System.out.println(49); 

This message asks System.out to execute its println method. The instructions inside the println method display the argument, SOMETHING_TO_DISPLAY, at the position of the cursor in the command window. And, println inserts a newline character immediately after the displayed argument---this makes the cursor in the command window move to the start of a fresh line.

As we learn in the next chapter, the Java language requires that textual phrases must be enclosed within double quotes, e.g., "Hello to you!". Textual phrases are called strings. The double quotes that surround strings prevent confusing strings with keywords. For example, "public class" is clearly a string and not two keywords side by side. In contrast, numbers like 49 are not strings and are not enclosed by double quotes.

Begin Footnote: But note that "49" is a string, because of the double quotes. The distinction between 49 and "49" becomes clear in the next chapter. End Footnote

Method println serves as System.out's ``communication'' or ``connection'' point, and the Hello object makes two such communications with System.out by using println, not unlike contacting a friend twice on the telephone.

Here is a final point, about spelling: The Java language distinguishes between upper-case and lower-case letters. Therefore, public is spelled differently from PUBLIC and Public, and only the first is accepted as the correct Java keyword. It is traditional to spell the names of classes beginning with a single upper-case letter, e.g., Hello, and method names tranditionally begin with a lower-case letter, e.g., println. Additional spelling guidelines are introduced in the next chapter.

Exercises

1. Write a Java program that displays your name on one line.
2. Write a Java program that prints your name, where your first (given) name is on a line by itself, and you last (family) name is on a line by itself.
3. For both of the previous exercises, explain why your program has the architecture presented in Figure 1. (This makes clear that different programs can be built in the same architectural style.)

2.3.1 An Execution Trace of the Application

When the Hello application is started by a user, the file, Hello.class, is copied into primary storage and becomes a Hello object.

Begin Footnote: The preceding explanation is imprecise, because it fails to explain that the ``object'' created from Hello.class is not the usual form of object described in Chapter 1. But it is not worth the pain at this point to state the distinction between a class that possesses an invoked static main method and one that possesses an invoked non-static constructor method. Our situation is similar to the one in an introductory physics course, where Newtonian physics is learned initially because it is simple and beautiful although slightly incorrect. In subsequent chapters, these technical issues are resolved. End Footnote

Here is a depiction of the Hello object (and System.out, which already exists) in primary storage:

Objects rest in primary storage and wait for messages. So, to start the computation, the computer (more precisely, the JVM) sends Hello a message to start its main method.

When Hello receives the message, it indeed starts main, whose statements are executed, one by one. We use a marker, >, to indicate which statement is executed first:

The statement, System.out.println("Hello to you!"), sends the message, println("Hello to you!"), to the System.out object. The argument, "Hello to you!", is what the method will print. (The enclosing double quotes are not printed, but you must include them, nonetheless.) This is an example of how one object sends a message to another object, awakening it from its rest.

The message is delivered to System.out, which puts its println method to work. In the interim, the Hello object waits:

Once println finishes, there is nothing more to execute in main's body,

Exercise

2.4 How One Object Constructs Another

The Hello example showed how an object can send messages to the preexisting object, System.out. But it is also possible for an object to construct its own, ``helper,'' objects as needed and send them messages. We see this in an example.

Say that you want an application that prints your name and the exact date and time, all on one line, in the command window. Of course, the date and time are dependent on when the program starts, and you cannot guess this in advance. Fortunately, the Java designers wrote a class, named class GregorianCalendar, that knows how to read the computer's internal clock. So, we construct an object that itself constructs a GregorianCalendar object and sends the GregorianCalendar object a message for the exact date and time. Figure 3 shows the architecture of the application we plan to build.

FIGURE 3: class diagram of an application that displays the time===========



ENDFIGURE================================================================

When this program is executed, we will see in the command window something like this:

Fred Mertz --- Fri Aug 13 19:07:42 CDT 2010

Finished

Figure 3 has an interesting architecture: NameAndDate is the controller, because it controls what will happen; System.out is the output view, because it presents the ``view'' of the program to its user; and GregorianCalendar is the model, because it ``models'' the computer clock---this is our first, simplistic example of a model-view-controller (MVC) architecture---see Chapter 1.

We must write the controller, class NameAndDate. The controller's main method asks System.out to print the text in the command window, but main must also ask a GregorianCalendar object for the exact time. To do this, main must construct the object first before it sends it a message. Here are the crucial steps main must do:

• Construct a new GregorianCalendar object, by saying

  new GregorianCalendar()
  

  The keyword, new, constructs an object from the class named GregorianCalendar. The matching parentheses, ( and ), can hold extra arguments if necessary; here, extra arguments are unneeded to construct the object.
• Give the newly created object a variable name so that we can send messages to the object:

  GregorianCalendar c = new GregorianCalendar();
  

  Here, the name is c. (The extra word, GregorianCalendar, is explained later.) We can use the name c like we used the name, System.out---we can send messages to the named object.
• Send object c a getTime message that asks it to consult the clock and reply with the date and time:

  c.getTime()
  

• Tell System.out to display this date and time:

  System.out.println(c.getTime());
  

  Recall that the statement, System.out.println(ARGUMENT), prints the ARGUMENT. Here, we insert, c.getTime(), which asks c to reply with the time as a response---it is the time received in response that is printed.

Figure 4 shows the program that uses the above steps. In addition to what we have just studied, several other new techniques are illustrated in the example. We explain them one by one.

FIGURE 4: application that prints the date and time====================

import java.util.*;
/** NameAndDate prints my name and the exact date and time. */
public class NameAndDate
{ public static void main(String[] args)
  { System.out.print("Fred Mertz --- "); 
    // The next statement creates an object:
    GregorianCalendar c = new GregorianCalendar();
    System.out.println(c.getTime());  // ask  c  the time and print its reply
    System.out.println();               
    System.out.println("Finished");
  }
}

ENDFIGURE==============================================================

To understand the first line,

import java.util.*;

Begin Footnote: Stated more precisely, when a class, C, is mentioned in a statement, the Java interpreter must locate the file, C.class. Normally, the interpreter searches in two places: (1) the folder in which the application was started, and (2) java.lang, a package of general-purpose classes. If C.class does not reside in either of these two places, an import statement must indicate where else the interpreter should search. End Footnote

The first statement within main says

System.out.print("Fred Mertz --- ");

The line,

// The next statement creates an object:

The statement,

GregorianCalendar c = new GregorianCalendar();

Variable names are developed fully in the next chapter, and our use of one to name for the GregorianCalendar object is merely a ``preview.''

The statement,

System.out.println(c.getTime());

Finally,

System.out.println()

Execution Trace

Because this example is an important one, we study its execution trace. The instant after the NameAndDate application is started, primary storage looks like this:

Once the text, Fred Mertz ---, is printed, the interpreter begins the next statement, which creates a new GregorianCalendar object---a segment of primary storage is allocated to hold the contents of a GregorianCalendar object, as described by class GregorianCalendar.

Begin Footnote: More specifically, the file, GregorianCalendar.class is used to construct the object in storage. End Footnote

We see the following:

Next, a storage space (called a cell) is created, and the address is placed into the cell. In this way, c is made to name the object at address a1:

Now, a println message to System.out must be sent. But the message's argument is not yet determined. For this reason, the interpreter sends a getTime() message to c, and since c names a cell that holds address a1, the object at address a1 is sent the message to execute the instructions in its getTime method:

Once getTime gets the date and time from the computer's clock, it returns the date and time to the exact position from which the message was sent:

After the time is placed in the position where it was requested, it becomes the argument part of the println message that is sent to System.out. This is a pattern that appears often in Java statements: When part of a statement is written within parentheses, the parenthesized part executes first, and the result, if any, is deposited in the parentheses.

System.out displays the date and time, and execution proceeds to the last two statements in main.

Finally, we note that only one message is sent to the GregorianCalendar object that is constructed by the application. In the case that an object is constructed and just one message is sent to it immediately thereafter, we need not give the object a name. Here is the application rewritten so that the object's name no longer appears:

import java.util.*;
/** NameAndDate prints my name and the exact date and time. */
public class NameAndDate
{ public static void main(String[] args)
  { System.out.print("Fred Mertz --- ");
    // The next statement constructs an object and sends it a getTime message:
    System.out.println(new GregorianCalendar().getTime());  
    System.out.println();                
    System.out.println("Finished");
  }
}

System.out.println(new GregorianCalendar().getTime());

Exercise

2.5 Repairing Compiler Error Messages

For example, here is a program that contains several errors. (Take a moment to locate them.)

public class test
{ public static main(String[] args)
  { System.out.println(Hello!)
}

Test.java:2: Invalid method declaration; return type required.
{ public static main(String[] args)
                ^

The compiler reports an error on the next line, also:

Test.java:3: ')' expected.
  { System.out.println(Hello!)
                              ^

There is also an error in the following line:

Test.java:4: '}' expected.
}
 ^

Finally, the compiler reports an error at Line 1:

Test.java:1: Public class test must be defined in a file called "test.java".
public class test
             ^

Once we repair the errors, we have this program:

public class Test
{ public static void main(String[] args)
  { System.out.println("Hello!") }
}

Test.java:3: ';' expected.
  { System.out.println("Hello!") }
                                  ^

Although the Java compiler will methodically locate all the grammar errors in an application, a programmer should not rely on it as a kind of ``oracle'' that announces when an application is ready to be executed. Indeed, a programmer should be familiar with the appearance (syntax) and meanings (semantics) of the statements in the Java language. An introduction to these notions appears in the sections at the end of this chapter, and Appendix I provides a thorough description of the syntax and semantics for the subset of the Java language used in this text.

Finally, remember that the compiler's role is to enforce spelling and grammar and not to comment on the suitability of the statements in the program. For example, the English sentence, ``Turn left into the Atlantic Ocean, and drive on the ocean floor until you reach the east coast of France'', is a grammatically correct but procedurally and geographically dubious instruction for someone who wishes to travel from New York City to Paris! In a similar way, a program can contain grammatically correct but dubious statements.

For this reason, the Java compiler can not guarantee that a program will perform the actions that its author intends. What the author intends lives in her brain; how she converts these intentions into written instructions cannot be checked by the compiler! For this reason, we must study design, testing, and validation techniques that help a programmer correctly convert her intentions into programs. We encounter these techniques in subsequent chapters.

2.6 Summary

New Constructions

• Java class (from Figure 2):

  public class Hello 
  {
    ...
  }
  

• main method (from Figure 2):

  public static void main(String[] args) 
  { 
    ...
  }
  

• comment (from Figure 2):

  /** Hello  prints two lines in the command window */
  

• internal comment (from Figure 4):

  // The next statement creates an object:
  

• message-sending statement (from Figure 2):

  System.out.println("Hello to you!");
  

• constructing a new object (from Figure 4):

  new GregorianCalendar()
  

• variable name (from Figure 4):

  GregorianCalendar c = new GregorianCalendar();
  

New Terminology

• application: a Java program that is started by a human; an object is constructed in primary storage and a message is sent to the object to execute its main method.
• statement: a single instruction within a Java program; typically terminated by a semicolon.
• main method: the ``start up'' method that executes first when an application is started.
• argument: extra information that is appended to a message sent to an object; enclosed within parentheses following the method name within the message.
• comment: an explanation inserted into a program for a human (and not the computer) to read.
• string: a sequence of characters, enclosed by double quotes, e.g., "hello".
• Java Development Kit (JDK): a collection of programs, available from Sun Microsystems, that let a user compile and start a Java application from the command window.
• integrated development environment (IDE): a single program from which a use can edit, compile, start, and monitor a Java application
• execution trace: a sequence of pictures of primary storage, showing the changes to the objects as the computer executes statements one by one.
• address (of an object): an object's ``name'' within primary storage; used to send messages to it.
• variable name: a name of a cell where a value, such as the address of an object, is saved. (See Chapter 3 for a fuller development.)

Additional Points to Remember

• A Java application must be compiled before it can be started. When a file, C.java, is compiled, another file, C.class is created, and objects are constructed from C.class when the user starts C. A message is sent to object C's main method.
• When an application is created in primary storage, there are already other preexisting objects, such as System.out, to which messages can be sent.
• An object can create other objects by stating the keyword, new, followed by the name of the class from which the object is to be constructed.
• When an object is created from a class that is located in a Java package, the package's name should be explicitly imported so that the Java interpreter can locate the class. For example, class GregorianCalendar is located in the package, java.util, so we import the package to use the class:

  import java.util.*;
  public class ExampleOfImportation
  {
    ... new GregorianCalendar() ...
  }
  

New Constructions for Later Use

• System.out: the object that communicates with the command window. Methods:
  • print(ARGUMENT): displays ARGUMENT in the command window at the position of the cursor
  • println(ARGUMENT): displays ARGUMENT, appended to a newline character, in the command window at the position of the cursor.
• class GregorianCalendar (a class from which one can construct objects that read the computer's clock). Found in the package, java.util. Method:
  • getTime(): returns the current time

2.7 Programming Exercises

1. Write a Java program that displays your name and postal address on three or more lines. Next, use a GregorianCalendar object to print the date and time before your name.
2. Write a Java program that appears to do nothing at all.
3. Create two GregorianCalendar objects by inserting these two statements,

   System.out.println( new GregorianCalendar().getTime() );
   System.out.println( new GregorianCalendar().getTime() );
   

   into a main method. What happens when you execute the program?
4. Modify the program from the previous exercise as follows: Insert between the two statements this Java instruction:

   try { Thread.sleep(5000); }
   catch (InterruptedException e) { }
   

   We will not dissect this complex statement---simply stated, it causes the main method to delay for 5000 milliseconds (that is, 5 seconds). Compile and execute the program. What happens?
5. Write the smallest Java program (fewest number of characters) that you can. Is there a largest possible (most number of characters) program?
6. Write a Java program that draws this picture on the display:

     /\
    /  \
    ----
   |  - |
   | | ||
   

2.8 Beyond the Basics

2.8.1 Syntax

Appendix I gives a precise description of the syntax for the subset of the Java language we use in this text. The description is precise, detailed, and a bit tedious. Nonetheless, it is important that we learn to read such definitions, because they tell us precisely what grammatically correct Java programs look like.

For exercise, we present here the part of the syntax definition that matches the examples seen in this chapter. (Note: because they are developed more fully in the next chapter, we omit the presentation of variable names here.)

Class

CLASS ::=  public class IDENTIFIER { METHOD* }

We see that a well-formed CLASS begins with the keywords, public and class, followed by an entity called an IDENTIFIER, which we describe later. (The IDENTIFIER is the class's name, e.g., NameAndDate in Figure 4. For now, think of an IDENTIFIER as a single word.)

Following the class's name is a left bracket, {, then zero or more entities called METHODs, defined momentarily. (The * should be read as ``zero or more.'') A class is concluded with the right bracket, }.

The classes in Figures 2 and 4 fit this format---both classes hold one method, main.

Method

METHOD ::=  public static void METHOD_HEADER 
            METHOD_BODY

METHOD_HEADER ::=  IDENTIFIER ( FORMALPARAM_LIST? )

In this chapter, the FORMALPARAM_LIST was always String[] args, but we study other forms in a later chapter.

METHOD_BODY ::=  { STATEMENT* }

Statement

STATEMENT  ::=  INVOCATION ;
INVOCATION ::=  RECEIVER . IDENTIFIER ( ARGUMENT_LIST? )

The syntax rule for well-formed RECEIVERs is instructive:

RECEIVER ::= IDENTIFIER
            | RECEIVER . IDENTIFIER
            | OBJECT_CONSTRUCTION

Notice how the recursive (self-referential) definition of RECEIVER gives a terse and elegant way to state precisely that a RECEIVER can be a sequence of IDENTIFIERs separated by periods.

Object Construction

OBJECT_CONSTRUCTION ::=  new IDENTIFIER ( ARGUMENT_LIST? )

Messages to objects and newly constructed objects can use ARGUMENT_LISTs:

ARGUMENT_LIST ::=  EXPRESSION [[ , EXPRESSION ]]*
EXPRESSION ::= LITERAL | INVOCATION

For example, say that "hello" and 49 are both well-formed LITERALs. Then, both are well-formed EXPRESSIONs, and this means "hello", 49 is a well-formed ARGUMENT_LIST

All the examples in this chapter used ARGUMENT_LISTs that consisted of zero (e.g., System.out.println()) or just one (e.g., System.out.println(new GregorianCalendar(). getTime())) EXPRESSIONs.

Within Chapter 2, an EXPRESSION was either a LITERAL, like "hello", or an INVOCATION (new GregorianCalendar().getTime()).

Literal and Identifier

2.8.2 Semantics

The syntax rules in the previous section tell us nothing about what a Java application means (that is, what the application does). When we discuss a program's meaning, we are discussing its semantics. From the examples in this chapter, we learned the informal semantics of a number of Java constructions. As a exercise, we repeat this knowledge here. The subsections that follow are organized to match the similarly named subsections of syntax rules in the previous section, and by reading both in parallel, you can gain a systematic understanding of the syntax and semantics of the Java constructions used in this Chapter.

Class

Begin Footnote: As noted earlier in the Chapter, this explanation deliberately avoids technicalities regarding invocation of so-called static methods of classes. The issue will be handled later. End Footnote

A message is sent to the newly constructed object's main METHOD.

Method

public static void METHOD_HEADER METHOD_BODY

The statements in the METHOD_BODY are executed, one by one, in order. It is possible for the last statement in the METHOD_BODY to ``reply'' with an ``answer'' to the message. We study this behavior in a later chapter.

Statement

Object Construction

2.8.3 Java Packages

It is painful to write any computer program completely ``from scratch'' and it is better to use already-written objects and classes to simplify the task. We did this in the examples in this chapter when we used the System.out object and the GregorianCalendar class to help us display text in the command window and ask the computer's clock the time.

Objects and classes like these two are organized into folders called packages. System.out lives in a package named java.lang, and GregorianCalendar appears in java.util. The former package, java.lang, contains many objects and classes that are essential for basic programming. Indeed, java.lang contains those Java-components that represent the ``computing environment'' portrayed in Figure 2 in Chapter 1. For this reason, every Java application automatically gets use of the objects and classes in java.lang.

But there are many other Java packages---for graphics, networking, disk-file manipulation, general utilities---and if an application wishes to use a component from one of these packages, then that package must be explicitly imported for the use of the application. We saw this in Figure 4, where we stated import java.util.* at the beginning of class NameAndDate so that class GregorianCalendar could be found. (java.util is the general utility package; it has classes that can create clocks, calendars, and other structures. In Chapter 4, we will import the java.awt and javax.swing packages, whose classes know how to draw graphics on the display.)

2.8.4 Java API

There are literally hundreds of objects and classes organized into Java's two dozen packages. How do we learn the names of these components and how to use them? It is a bit early to undertake this ambitious task, but we can at least learn where to look for basic information---we read Java's Application Programming Interface (API) documentation.

The Java API documentation is a summary of the contents of the packages; it is a bit like a dictionary, where each word is listed with its proper spelling and a one-sentence description of its use. The Java API documentation lists the components of its packages and gives short explanations about how to use the components.

Fortunately, the Java API documentation is organized as a collection of Web pages. It is best to download into your computer a complete set of the API's web pages; see http://java.sun.com for details about ``Documentation.'' But you are welcome to survey the API documentation at Sun's Web site at the URL just mentioned, as well.

Let's make a quick search for information about the System.out object. We begin at the API's starting Web page, which looks something like the following:

When we reach the Web page for java.lang, we see a description of the package:

In this way, you can browse through the Java packages and learn their contents. (As an exercise, you should consult the Web page for java.util and locate class GregorianCalendar; you will see that it has many more methods than just the getTime method we used so far.)