Java Programming Basics

In this chapter, you find the basics of writing simple Java programs. The programs you see in this chapter don't do anything very interesting; they just display simple information on a console (in Windows, that's a command-prompt window). You need to cover a few more chapters before you start writing programs that do anything worthwhile. But the simple programs you see in this chapter are sufficient to illustrate the basic structure of Java programs.

Be warned that in this chapter I introduce you to several Java programming features that are explained in greater detail in later chapters. For example, you see some variable declarations, a method, and even an if statement and a for loop. The goal of this chapter isn't to march you into instant proficiency with these programming elements, but just to introduce you to them.

Looking at the Infamous Hello, World! Program

Many programming books begin with a simple example program that displays the text “Hello, World!” on the console. In Book I, Chapter 1, I show you a Java program that does that to compare it with a similar program written in C. Now, take a closer look at each element of this program, shown in Listing 1-1.

Listing 1-1: The HelloApp Program

public class HelloApp → 1 { → 2 public static void main(String[] args) → 3 { → 4 System.out.println("Hello, World!"); → 5 } → 6 } → 7

Later in this chapter, you discover in detail all the elements that make up this program. But first, I want to walk you through it word by word.

Lines 1 and 2 mark the declaration of a public class named HelloApp:

Open table as spreadsheet

Lines 3 through 6 define a method of the HelloApp class named main:

Open table as spreadsheet

To run this program, you must first use a text editor to enter it-exactly as it appears in Listing 1-1-into a text file named HelloApp.java. Then you can compile it by running the following command at a command prompt:

javac HelloApp.java

This command creates a class file named HelloApp.class that contains the Java bytecodes compiled for the HelloApp class.

You can run the program by entering this command:

java HelloApp

Now that you've seen what a Java program actually looks like, you're in a better position to understand exactly what this command does. First, it loads the Java Virtual Machine into memory. Then it locates the HelloApp class, which must be contained in a file named HelloApp.class. Finally, it runs the main method of the HelloApp class. The main method, in turn, displays the message “Hello, World!” on the console.

The rest of this chapter describes some of the basic elements of the Java programming language in greater detail.

Dealing with Keywords

A keyword is a word that has a special meaning defined by the Java programming language. The program shown earlier in Listing 1-1 uses four keywords: public, class, static, and void. In all, Java has 53 keywords. They're listed in alphabetical order in Table 1-1.

Stranger still, two keywords-const and goto-are reserved by Java but don't do anything. Both are carryovers from the C++ programming language. The const keyword defines a constant, which is handled in Java by the final keyword. As for goto, it's a C++ statement that is considered anathema to object-oriented programming purists, so it isn't used in Java. Java reserves it as a keyword solely for the purpose of scolding you if you attempt to use it.

Considering the Java community's disdain for Visual Basic, it's surprising that the error messages generated when you capitalize keywords aren't more insulting. Accidentally capitalizing a keyword in Visual Basic style can really throw the Java compiler for a loop. For example, consider this program, which contains the single error of capitalizing the word For:

public class CaseApp { public static void main(String[] args) { For (int i = 0; i<5; i++) System.out.println("Hi"); } }

When you try to compile this program with Java 1.6, the compiler generates a total of four error messages for this one mistake:

C:Java AIOCaseApp.java:5: '.class' expected For (int i = 0; i<5; i++) ^ C:Java AIOCaseApp.java:5: illegal start of type For (int i = 0; i<5; i++) ^ C:Java AIOCaseApp.java:5: not a statement For (int i = 0; i<5; i++) ^ C:Java AIOCaseApp.java:5: ';' expected For (int i = 0; i<5; i++) ^ 4 errors For (int i = 0; i<5; i++)

Even though this single mistake generates four error messages, not one of the messages actually points to the problem. The little arrow beneath the source line indicates what part of the line is in error, and none of these error messages have the arrow pointing anywhere near the word For! The compiler isn't smart enough to realize that you meant for instead of For. So it treats For as a legitimate identifier, and then complains about everything else on the line that follows it. It would be much more helpful if it generated an error message like this:

C:Java AIOCaseApp.java:5: 'For' is not a keyword For (int i = 0; i<5; i++) ^

The moral of the story is that keywords are case-sensitive, and if your program won't compile and the error messages don't make any sense, check for keywords that you've mistakenly capitalized.

Working with Statements

Like most programming languages, Java uses statements to build programs. Unlike most programming languages, Java doesn't use statements as its fundamental unit of code. Instead, it gives that honor to the class. However, every class must have a body, and the body of a class is made up of one or more statements. In other words, you can't have a meaningful Java program without at least one statement. The following sections describe the ins and outs of working with Java statements.

Types of statements

Java has many different types of statements. Some statements simply create variables that you can use to store data. These types of statements are often called declaration statements, and tend to look like this:

int i; String s = "This is a string"; Customer c = new Customer();

Another common type of statement is an expression statement, which performs calculations. Here are some examples of expression statements:

i = a + b; salesTax = invoiceTotal * taxRate; System.out.println("Hello, World!");

Notice that the last statement in this group is the same as line 5 in Listing 1-1. Thus, the single statement in the HelloApp program is an expression statement.

There are many other kinds of statements besides these two. For example, if-then statements execute other statements only if a particular condition has been met. And statements such as for, while, or do execute whole groups of statements one or more times.

if (total > 100) discountPercent = 10;

Here the variable named discountPercent is given a value of 10 if the value of the total variable is greater than 100. The expression statement ends with semicolons, but the if statement itself doesn't. (The Java compiler lets you know if you use a semicolon when you shouldn't.)

White space

In Java, the term white space refers to one or more consecutive space characters, tab characters, or line breaks. All white space is considered the same. In other words, a single space is treated the same as a tab or line break or any combination of spaces, tabs, or line breaks.

If you've programmed in Visual Basic, white space is different from what you're used to. In Visual Basic, line breaks mark the end of statements unless special continuation characters are used. In Java, you don't have to do anything special to continue a statement onto a second line. Thus the statement

x = (y + 5) / z;

is identical to this statement:

x = (y + 5) / z;

In fact, you could write the above statement like this if you wanted:

x = ( y + 5 ) / z ;

I wouldn't advise it, but the statement does compile and execute properly.

Working with Blocks

A block is a group of one or more statements that's enclosed in braces. A block begins with an opening brace ({) and ends with a closing brace (}). Between the opening and closing braces, you can code one or more statements. For example, here's a block that consists of three statements:

{ int i, j; i = 100; j = 200; }

Here the statement can be a single statement or a block. If you find this idea confusing, don't worry. It will make more sense when you turn to Book II, Chapter 4.

if (i > 0) { String s = "The value of i is " + i; System.out.print(s); }

The other style is to place the opening brace for the block on the same line as the statement the block is associated with, like this:

if (i > 0) { String s = "The value of i is " + i; System.out.print(s); }

Which style you use is a matter of personal preference. I prefer the first style, and that's the style I use throughout this book. But either style works-and many programmers prefer the second style because it's more concise.

Creating Identifiers

An identifier is a word that you make up to refer to a Java programming element by name. Although you can assign identifiers to many different types of Java elements, they're most commonly used for the following elements:

• Classes, such as the HelloApp class in Listing 1-1.
• Methods, such as the main method in Listing 1-1.
• Variables and fields, which hold data used by your program.
• Parameters, which pass data values to methods.

You must follow a few simple rules when you create identifiers:

• Identifiers are case-sensitive. As a result, SalesTax and salesTax are distinct identifiers.
• Identifiers can be made up of upper-or lowercase letters, numerals, underscore characters (_), and dollar signs ($).
• All identifiers must begin with a letter. Thus a15 is a valid identifier but 13Unlucky isn't (because it begins with a numeral).
• An identifier can't be the same as any of the Java keywords listed in Table 1-1. Thus you can't create a variable named for or a class named public.

• Tip

  The Java language specification recommends that you avoid using dollar signs in names you create. Instead, dollar signs are used by code generators to create identifiers. Thus avoiding dollar signs helps you avoid creating names that conflict with generated names.

Crafting Comments

A comment is a bit of text that provides explanations of your code. Comments are completely ignored by the compiler, so you can place any text you wish in a comment. Using plenty of comments in your programs is a good idea to explain what your program does and how it works.

Java has three basic types of comments: end-of-line comments, traditional comments, and JavaDoc comments. More about that coming right up.

End of line comments

An end-of-line comment begins with the sequence // and ends at the end of the line. You can place an end-of-line comment at the end of any line. Everything you type after the // is ignored by the compiler. For example:

total = total * discountPercent; // calculate the discounted total

If you want, you can also place end-of-line comments on separate lines, like this:

// calculate the discounted total total = total * discountPercent;

You can place end-of-line comments in the middle of statements that span two or more lines. For example:

total = (total * discountPercent) // apply the discount first + salesTax; // then add the sales tax

Traditional comments

A traditional comment begins with the sequence /* and ends with the sequence */ and can span multiple lines. Here's an example:

/* HelloApp sample program. This program demonstrates the basic structure that all Java programs must follow. */

A traditional comment can begin and end anywhere on a line. If you want, you can even sandwich a comment between other Java programming elements, like this:

x = (y + /* a strange place for a comment */ 5) / z;

Usually traditional comments appear on separate lines. One common use for traditional comments is to place a block of comment lines at the beginning of a class to indicate information about the class-such as what the class does, who wrote it, and so on. However, that type of comment is usually better coded as a JavaDoc comment, as described in the next section.

/* int x, y, z; y = 10; z = 5; x = (y + /* a strange place for a comment */ 5) / z; */

Here I tried to comment out a range of lines that already included a traditional comment. Unfortunately, the */ sequence near the end of the fifth line is interpreted as the end of the traditional comment that begins in the first line. Then, when the compiler encounters the */ sequence in line 6, it generates an error message.

JavaDoc comments

JavaDoc comments are actually a special type of traditional comment that you can use to create Web-based documentation for your programs-automatically. Because you'll have a better appreciation of JavaDoc comments when you know more about object-oriented programming, I devote a section in Book III, Chapter 8 to creating and using JavaDoc comments.

Introducing Object Oriented Programming

Having presented some of the most basic elements of the Java programming language, most Java books would next turn to the important topics of variables and data types. However, because Java is an inherently object-oriented programming language, and classes are the heart of object-oriented programming, I look next at classes to explore the important role they play in creating objects. I get to variables and data types first thing in the next chapter.

Understanding classes and objects

As I've already mentioned, a class is code that defines the behavior of a Java programming element called an object. An object is an entity that has both state and behavior. The state of an object consists of any data that the object might be keeping track of, and the behavior consists of actions that the object can perform. The behaviors are represented in the class by one or more methods that can be called upon to perform actions.

The difference between a class and an object is similar to the difference between a blueprint and a house. A blueprint is a plan for a house. A house is an implementation of a blueprint. One set of blueprints can be used to build many houses. Likewise, a class is a plan for an object, and an object is-in Java terms-an instance of a class. You can use a single class to create more than one object.

When an object is created, Java sets aside an area of computer memory that's sufficient to hold all the data that's stored by the object. As a result, each instance of a class has its own data, independent of the data used by other instances of the same class.

Understanding static methods

You don't necessarily have to create an instance of a class to use the methods of the class. If a method is declared with the static keyword, the method can be called without first creating an instance of the class. That's because static methods are called from classes, not from objects.

The main method of a Java application must be declared with the static keyword. That's because when you start a Java program by using the java command from a command prompt, Java doesn't create an instance of the application class. Instead, it simply calls the program's static main method.

The difference between static and non-static methods will become more apparent when you look at object-oriented programming in more depth in Book III. But for now, consider this analogy. The blueprints for a house include the details about systems that actually perform work in a finished house, such as electrical and plumbing systems. In order to use those systems, you have to actually build a house. In other words, you can't turn on the hot water by using the blueprint alone; you have to have an actual house with an actual device to heat the water.

However, the blueprints do include detailed measurements of the dimensions of the house. As a result, you can use the blueprints to determine the square footage of the living room. Now imagine that the blueprints actually had a built-in calculator that would display the size of the living room if you pushed the "Living Room" button. That button would be like a static method in a class: You don't actually have to build a house to use the button; you can activate it from the blueprints alone.

Many Java programs-in fact, many of the programs in the rest of Book II-are entirely made up of static methods. However, most realistic programs require that you create one or more objects that the program uses as it executes. As a result, learning how to create simple classes and how to create objects from those classes are basic skills in Java programming.

Creating an object from a class

In Java, you can create an object from a class in several ways. But the most straightforward is to create a variable that provides a name you can use to refer to the object, use the new keyword to create an instance of the class, and then assign the resulting object to the variable. The general form of a statement that does that bit of magic looks like this:

ClassName variableName = new ClassName();

For example, to create an object instance of a class named Class1 and assign it to a variable named myClass1Object, you would write a statement like this:

Class1 myClass1Object = new Class1();

Why do you have to list the class name twice? The first time, you're providing a type for the variable. In other words, you're saying that the variable you're creating here can be used to hold objects created from the Class1 class. The second time you list the class name, you're creating an object from the class. The new keyword tells Java to create an object, and the class name provides the name of the class to use to create the object.

The equal sign (=) is an assignment operator. It simply says to take the object created by the new keyword and assign it to the variable. Thus, this statement actually does three things:

• It creates a variable named myClass1Object that can be used to hold objects created from the Class1 class. At this point, no object has been created-just a variable that can be used to store objects.
• It creates a new object in memory from the Class1 class.
• It assigns this newly created object to the myClass1Object variable. That way, you can use the myClassObject variable to refer to the object that was created.

A program that uses an object

To give you an early look at what object-oriented programming really looks like, Listings 1-2 and 1-3 show another version of the HelloApp application-this time using two classes, one of which is actually made into an object when the program is run. The first class, named HelloApp2, is shown in Listing 1-2. This class is similar to the HelloApp class shown in Listing 1-1. However, it uses an object created from the second class, named Greeter, to actually display the “Hello, World!” message on the console. The Greeter class is shown in Listing 1-3. It defines a method named sayHello that displays the message.

The HelloApp2 class

The HelloApp2 class is shown in Listing 1-2.

Listing 1-2: The HelloApp2 Class

// This application displays a hello message on → 1 // the console by creating an instance of the // Greeter class, then calling the Greeter // object's sayHello method. public class HelloApp2 → 6 { public static void main(String[] args) → 8 { Greeter myGreeterObject = new Greeter(); → 10 myGreeterObject.sayHello(); → 11 } }

The following paragraphs describe the key points:

Open table as spreadsheet

The Greeter class

The Greeter class is shown in Listing 1-3.

Listing 1-3: The Greeter Class

// This class creates a Greeter object → 1 // that displays a hello message on // the console. public class Greeter → 5 { public void sayHello() → 7 { System.out.println("Hello, World!"); → 9 } }

The following paragraphs describe the key points:

Open table as spreadsheet

So what s the difference?

You might notice that the only line that actually does any real work in the HelloApp2 program is line 9 in the Greeter class (Listing 1-3), and this line happens to be identical to line 5 in the original HelloApp class (Listing 1-1). Other than the fact that the second version requires roughly twice as much code as the first version, what really is the difference between these two applications?

Simply put, the first version is procedural, and the second is object-oriented. In the first version of the program, the main method of the application class does all the work of the application by itself: It just says hello. The second version defines a class that knows how to say hello to the world, and then creates an object from that class and asks that object to say hello. The application itself doesn't know (or even care) exactly how the Greeter object says hello. It doesn't know exactly what the greeting will be, what language the greeting will be in, or even how the greeting will be displayed.

To illustrate this point, consider what would happen if you used the Greeter class shown in Listing 1-4 rather than the one shown in Listing 1-3. This version of the Greeter class uses a Java library class called JOptionPane to display a message in a dialog box rather than in a console window. (I won't bother explaining how this code works, but you can find out more about it in the next chapter.) If you were to run the HelloApp2 application using this version of the Greeter class, you'd get the dialog box shown in Figure 1-1.

Figure 1-1: The class in Listing 1-4 displays this dialog box.

Listing 1-4: Another Version of the Greeter Class

// This class creates a Greeter object // that displays a hello message // in a dialog box. import javax. swing. JOptionPane; → 5 public class Greeter { public void sayHello() { JOptionPane.showMessageDialog(null, → 11 "Hello, World!", "Greeter", JOptionPane.INFORMATION_MESSAGE); } }

The important point to realize here is that the HelloApp2 class doesn't have to be changed to use this new version of the Greeter class. Instead, all you have to do is replace the old Greeter class with the new one, and the HelloApp2 class won't know the difference. That's one of the main benefits of object-oriented programming.

Importing Java API Classes

You may have noticed that the Greeter class in Listing 1-4 includes this statement:

import javax.swing.JOptionPane;

The purpose of the import statement is to let the compiler know that the program is using a class that's defined by the Java API called JOptionPane.

Because the Java API contains literally thousands of classes, some form of organization is needed to make the classes easier to access. Java does this by grouping classes into manageable groups called packages. In the previous example, the package that contains the JOptionPane class is named javax.swing.

Strictly speaking, import statements are never required. But if you don't use import statements to import the API classes your program uses, you must fully qualify the names of the classes when you use them by listing the package name in front of the class name. So, if the class in Listing 1-4 didn't include the import statement in line 5, you'd have to code line 11 like this:

javax.swing.JOptionPane.showMessageDialog(null, "Hello, World!", "Greeter", javax.swing.JOptionPane.INFORMATION_MESSAGE);

In other words, you'd have to specify javax.swing.JOptionPane instead of just JOptionPane whenever you referred to this class.