IN THIS CHAPTER

Introducing the famous Hello, World! program

Identifying basic elements of Java programs such as keywords, statements, and blocks

Finding different ways to add comments to your programs

Getting basic information about object-oriented programming

Identifying ways to import classes

In this chapter, you find the basics of writing simple Java programs. The programs you see in this chapter are very simple: 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. You see, for example, 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.

You can find all the code listings used in this book at www.dummies.com/go/javaaiofd5e.

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 1, 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:

1. →1 public: A keyword of the Java language that indicates that the element that follows should be made available to other Java elements. In this case, what follows is a class named HelloApp. As a result, this keyword indicates that the HelloApp class is a public class, which means other classes can use it. (In Book 3, Chapter 2, I cover the most common alternative to public: private. There are also other alternatives, but they’re covered in later chapters.)

   class: Another Java keyword that indicates that the element being defined here is a class. All Java programs are made up of one or more classes. A class definition contains code that defines the behavior of the objects created and used by the program. Although most real-world programs consist of more than one class, the simple programs you see in this minibook have just one class.

   HelloApp: An identifier that provides the name for the class being defined here. Whereas keywords, such as public and class, are words that are defined by the Java programming language, identifiers are words that you create to provide names for various elements you use in your program. In this case, the identifier HelloApp provides a name for the public class being defined here. (Although identifier is the technically correct term, sometimes identifiers are called symbols or names.)

2. →2 {: The opening brace on line 2 marks the beginning of the body of the class. The end of the body is marked by the closing brace on line 7. Everything that appears within these braces belongs to the class. As you work with Java, you’ll find that it uses these braces a lot. Pretty soon the third and fourth fingers on your right hand will know exactly where they are on the keyboard.

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

3. →3 public: The public keyword is used again, this time to indicate that a method being declared here should have public access. That means classes other than the HelloApp class can use it. All Java programs must have a class that declares a public method named main. The main method contains the statements that are executed when you run the program.

   static: You find all about the static keyword in Book 3, Chapter 3. For now, just take my word that the Java language requires that you specify static when you declare the main method.

   void: In Java, a method is a unit of code that can calculate and return a value. For example, you could create a method that calculates a sales total. Then the sales total would be the return value of the method. If a method doesn’t need to return a value, you must use the void keyword to indicate that no value is returned. Because Java requires that the main method not return a value, you must specify void when you declare the main method.

   main: Finally, here’s the identifier that provides the name for this method. As I’ve already mentioned, Java requires that this method be named main. Besides the main method, you can create additional methods with whatever names you want to use. You discover how to create additional methods in Book 2, Chapter 7. Until then, the programs consist of just one method named main.

   (String[] args): Oh, boy. This Java element is too advanced to thoroughly explain just yet. It’s called a parameter list, and it’s used to pass data to a method. Java requires that the main method must receive a single parameter that’s an array of String objects. By convention, this parameter is named args. If you don’t know what a parameter, a String, or an array is, don’t worry about it. You can find out what a String is in the next chapter, and parameters are in Book 2, Chapter 7; arrays are in Book 4. In the meantime, realize that you have to code (String[] args) on the declaration for the main methods in all your programs.

4. →4 Another{: Another set of braces begins at line 4 and ends at line 6. These braces mark the body of the main method. Notice that the closing brace in line 6 is paired with the opening brace in line 4, whereas the closing brace in line 7 is paired with the one in line 2. This type of pairing is commonplace in Java. In short, whenever you come to a closing brace, it’s paired with the most recent opening brace that hasn’t already been closed — that is, that hasn’t already been paired with a closing brace.

5. →5 System.out.println("Hello, World!");: This is the only statement in the entire program. It calls a method named println that belongs to the System.out object. The println method displays a line of text on the console. The text to be displayed is passed to the println method as a parameter in parentheses following the word println. In this case, the text is the string literal Hello, World! enclosed in a set of quotation marks. As a result, this statement displays the text Hello, World! on the console.

   Note that in Java, most (but not all) statements must end with a semicolon. Because this statement is the only one in the program, this line is the only one that requires a semicolon.

6. →6 }: Line 6 contains the closing brace that marks the end of the main method body that was begun by the brace on line 4.

   →7 Another }: Line 7 contains the closing brace that marks the end of the HelloApp class body that was begun by the brace on line 2. Because this program consists of just one class, this line also marks the end of the program.

To run this program, you must first use a text editor such as Notepad or TextPad to enter it — exactly as it appears in Listing 1-1 — in 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 (JVM) 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.

Strangely enough, three keywords listed in Table 1-1 — true, false, and null — aren’t technically considered to be keywords. Instead, they’re called literals. Still, they’re reserved for use by the Java language in much the same way that keywords are, so I lumped them in with the keywords.

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.

Like everything else in Java, keywords are case-sensitive. Thus, if you type If instead of if or For instead of for, the compiler complains about your error. Because Visual Basic keywords begin with capital letters, you’ll make this mistake frequently if you’ve programmed in Visual Basic.

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. 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, 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 has 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 the compiler generated an error message like this:

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

Better yet, for those of us old enough to remember Get Smart on TV:

C:Java AIOCaseApp.java:5: Thees ees Java! Vee do not capitalize keyverds here!
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.

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. Here’s a block that consists of three statements:

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

A block is itself a type of statement. As a result, any time the Java language requires a statement, you can substitute a block to execute more than one statement. In Book 2, Chapter 4, you discover that the basic syntax of an if statement is this:

if ( expression ) statement

Here 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 2, Chapter 4.

You can code the braces that mark a block in two popular ways. One is to place both braces on separate lines and then indent the statements that make up the block. For example:

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.

Note that even though a block can be treated as a single statement, you should not end a block with a semicolon. The statements within the block may require semicolons, but the block itself does not.

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 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

Identifiers are also sometimes called names. Strictly speaking, a name isn’t quite the same thing as an identifier; a name is often made up of two or more identifiers connected with periods (called dots). In line 5 of Listing 1-1, for example, System and out are both identifiers, but System.out is a name. In practice, the terms name and identifier are used interchangeably.

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 ( $ ). Thus, identifier names such as Port1, SalesTax$, and Total_Sales.
• 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.
• The Java language specification recommends that you avoid using dollar signs in names you create, because code generators use dollar signs 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. The compiler ignores comments, so you can place any text you want in a comment. Using plenty of comments in your program is a good way 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 is coming right up.

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. Because Java is an inherently object-oriented programming language, however, and because 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.

So what’s the difference?

You may 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 in a list 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.

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, recompile the Greeter class, 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.

Here are some additional rules for working with import statements:

• import statements must appear at the beginning of the class file, before any class declarations.
• You can include as many import statements as are necessary to import all the classes used by your program.
• You can import all the classes in a particular package by listing the package name followed by an asterisk wildcard, like this:

  import javax.swing.*;

• Because many programs use the classes that are contained in the java.lang package, you don’t have to import that package. Instead, those classes are automatically available to all programs. The System class is defined in the java.lang package. As a result, you don’t have to provide an import statement to use this class.

• The latest version of Java, called JDK 9, introduces a new feature for managing packages called the Java Platform Module System. I cover this new feature in Book 3, Chapter 8.