Java Is a Language

Java is a language in which developers express source code (program text). Java’s syntax (rules for combining symbols into language features) is partly patterned after the C and C++ languages to shorten the learning curve for C/C++ developers.

The following list identifies a few similarities between Java and C/C++:

• Java and C/C++ share the same single-line and multiline comment styles. Comments let you document source code.
• Many of Java’s reserved words are identical to their C/C++ counterparts (for, if, switch, and while are examples) and C++ counterparts (catch, class, public, and try are examples).
• Java supports character, double precision floating-point, floating-point, integer, long integer, and short integer primitive types, and via the same char, double, float, int, long, and short reserved words.
• Java supports many of the same operators, including arithmetic (+, -, *, /, and %) and conditional (?:) operators.
• Java uses brace characters ({ and }) to delimit blocks of statements.

The following list identifies a few differences between Java and C/C++:

• Java supports an additional comment style known as Javadoc. (I briefly introduce Javadoc in Chapter 2.)
• Java provides reserved words not found in C/C++ (extends, strictfp, synchronized, and transient are examples).
• Java doesn’t require machine-specific knowledge. It supports the byte integer type (see http://en.wikipedia.org/wiki/Integer_(computer_science)); doesn’t provide a signed version of the character type; and doesn’t provide unsigned versions of integer, long integer, and short integer. Furthermore, all of Java’s primitive types have guaranteed implementation sizes, which is an important part of achieving portability (discussed later). The same cannot be said of equivalent primitive types in C and C++.
• Java provides operators not found in C/C++. These operators include instanceof and >>> (unsigned right shift).
• Java provides labeled break and continue statements that you will not find in C/C++.

You will learn about single-line and multiline comments in Chapter 2. Also, you will learn about reserved words, primitive types, operators, blocks, and statements (including labeled break and continue) in that chapter.

Java was designed to be a safer language than C/C++. It achieves safety in part by not letting you overload operators and by omitting C/C++ features such as pointers (variables containing addresses—see http://en.wikipedia.org/wiki/Pointer_(computer_programming)).

Java also achieves safety by modifying certain C/C++ features. For example, loops must be controlled by Boolean expressions instead of integer expressions where 0 is false and a nonzero value is true. (There is a discussion of loops and expressions in Chapter 2.)

Suppose you must code a C/C++ while loop that repeats no more than 10 times. Being tired, you specify while (x) x++; (assume that x is an integer-based variable initialized to 0—I discuss variables in Chapter 2) where x++ adds 1 to x’s value. This loop doesn’t stop when x reaches 10; you have introduced a bug.

This problem is less likely to occur in Java because it complains when it sees while (x). This complaint requires you to recheck your expression, and you will then most likely specify while (x != 10). Not only is safety improved (you cannot specify just x), meaning is also clarified: while (x != 10) is more meaningful than while (x).

These and other fundamental language features support classes, objects, inheritance, polymorphism, and interfaces. Java also provides advanced features related to nested types, packages, static imports, exceptions, assertions, annotations, generics, enums, and more. Subsequent chapters explore most of these language features.

Java Is a Platform

Java is a platform consisting of a virtual machine and an execution environment. The virtual machine is a software-based processor that presents an instruction set. The execution environment consists of libraries for running programs and interacting with the underlying operating system.

The execution environment includes a huge library of prebuilt classfiles that perform common tasks, such as math operations (e.g., trigonometry) and network communications. This library is commonly referred to as the standard class library.

A special Java program known as the Java compiler translates source code into instructions (and associated data) that are executed by the virtual machine. These instructions are known as bytecode.

The compiler stores a program’s bytecode and data in files having the .class extension. These files are known as classfiles because they typically store the compiled equivalent of classes, a language feature discussed in Chapter 3.

A Java program executes via a tool (e.g., java) that loads and starts the virtual machine and passes the program’s main classfile to the machine. The virtual machine uses a classloader (a virtual machine or execution environment component) to load the classfile.

After the classfile has been loaded, the virtual machine’s bytecode verifier component makes sure that the classfile’s bytecode is valid and doesn’t compromise security. The verifier terminates the virtual machine when it finds a problem with the bytecode.

Assuming that all is well with the classfile’s bytecode, the virtual machine’s interpreter interprets the bytecode one instruction at a time. Interpretation consists of identifying bytecode instructions and executing equivalent native instructions.

When the interpreter learns that a sequence of bytecode instructions is executed repeatedly, it informs the virtual machine’s Just in Time (JIT) compiler to compile these instructions into native code.

JIT compilation is performed only once for a given sequence of bytecode instructions. Because the native instructions execute instead of the associated bytecode instruction sequence, the program executes much faster.

During execution, the interpreter might encounter a request to execute another classfile’s bytecode. When that happens, it asks the classloader to load the classfile and the bytecode verifier to verify the bytecode prior to executing that bytecode.

The platform side of Java promotes portability by providing an abstraction over the underlying platform. As a result, the same bytecode runs unchanged on Windows-based, Linux-based, Mac OS X-based, and other platforms.

The platform side of Java also promotes security by providing a secure environment (e.g., the bytecode verifier) in which code executes. The goal is to prevent malicious code from corrupting the underlying platform (and possibly stealing sensitive information).

Java SE, Java EE, Java ME, and Android

Developers use different editions of the Java platform to create Java programs that run on desktop computers, web browsers, web servers, mobile information devices (e.g., feature phones), and embedded devices (e.g., television set-top boxes):

• Java Platform, Standard Edition(Java SE): The Java platform for developing applications, which are stand-alone programs that run on desktops. Java SE is also used to develop applets, which are programs that run in web browsers.
• Java Platform,Enterprise Edition (Java EE): The Java platform for developing enterprise-oriented applications and servlets, which are server programs that conform to Java EE’s Servlet API. Java EE is built on top of Java SE.
• Java Platform,Micro Edition (Java ME): The Java platform for developing MIDlets, which are programs that run on mobile information devices, and Xlets, which are programs that run on embedded devices.

Developers also use a special Google-created edition of the Java platform (see http://developer.android.com/index.html) to create Android apps that run on Android-enabled devices. This edition is known as the Android platform.

Google’s Android platform presents a Dalvik virtual machine that runs on top of a specially modified Linux kernel. An Android app’s Java source code is compiled into Java classfiles, which are then translated into a special file for Dalvik to execute.

In this book, I cover the Java language (supported by Java SE and Android) and various Java SE APIs that are also supported by Android. I focus on language features through Java version 5 and on Java APIs through Java 5, with a small amount of Java 6.

Installing and Exploring the JDK

The Java Runtime Environment (JRE) implements the Java SE platform and makes it possible to run Java programs. The public JRE can be downloaded from Oracle’s Java SE Downloads page (http://oracle.com/technetwork/java/javase/downloads/index.html).

However, the public JRE doesn’t make it possible to develop Java programs. For that task, you need to download and install the Java SE Development Kit (JDK), which contains development tools (including the Java compiler) and a private JRE.

The Java SE Downloads page also provides access to the current JDK, which is JDK 7 Update 9 at time of writing. Click the Download JDK link (on the page at http://oracle.com/technetwork/java/javase/downloads/index.html) to download the current JDK’s installer program for your platform.

The JDK installer places the JDK in a home directory. (It can also install the public JRE in another directory.) On my Windows 7 platform, the home directory is C:Program FilesJavajdk1.7.0_06. (I currently use JDK 7 Update 6.)

The home directory contains various files (e.g., README.html, which provides information about the JDK, and src.zip, which provides the standard class library source code) and subdirectories, including the following three important subdirectories:

• bin: This subdirectory contains assorted JDK tools. You’ll use only a few of these tools in this book, mainly javac (Java compiler), java (Java application launcher), jar (Java archive creator, updater, and extractor), and javadoc (Java documentation generator).
• jre: This subdirectory contains the JDK’s private copy of the JRE, which lets you run Java programs without having to download and install the public JRE.
• lib: This subdirectory contains library files that are used by JDK tools. For example, tools.jar contains the Java compiler’s classfiles—the compiler was written in Java.

You execute JDK tools at the command line, passing command-line arguments to a tool. You can learn about the command line and arguments via Wikipedia’s “Command-line interface” entry (http://en.wikipedia.org/wiki/Command-line_interface).

Now that you have installed the JDK and know something about its tools, you’re ready to explore a small DumpArgs application that outputs its command-line arguments to the standard output stream.

Listing 1-1 presents the DumpArgs application source code.

Listing 1-1.  Dumping Command-Line Arguments via main()’s args Array to the Standard Output Stream

public class DumpArgs
{
   public static void main (String[] args )
   {
      System.out.println("Passed arguments:");
      for (int i = 0; i < args .length; i++)
         System.out.println(args[i]);
   }
}

Listing 1-1’s DumpArgs application consists of a class named DumpArgs and a method within this class named main(), which is the application’s entry point and provides the code to execute. (You will learn about classes and methods in Chapter 3.)

The main() method includes a header that identifies this method and a block of code located between an open brace character ({) and a close brace character (}). As well as naming this method, the header provides the following information:

• public: This reserved word makes main() visible to the startup code that calls this method. If public wasn’t present, the compiler would output an error message stating that it couldn’t find a main() method. (I discuss reserved words in Chapter 2.)
• static: This reserved word causes this method to associate with the class instead of associating with any objects (discussed in Chapter 3) created from this class. Because the startup code that calls main() doesn’t create an object from the class to call this method, it requires that the method be declared static. Although the compiler will not report an error when static is missing, it will not be possible to run DumpArgs, which will not be an application when the proper main() method doesn’t exist.
• void: This reserved word indicates that the method doesn’t return a value. If you change void to a type’s reserved word (e.g., int) and then insert a statement that returns a value of this type (e.g., return 0;), the compiler will not report an error. However, you won’t be able to run DumpArgs because the proper main() method wouldn’t exist. (I discuss types in Chapter 2.)
• (String[] args): This parameter list consists of a single parameter named args of type String[]. Startup code passes a sequence of command-line arguments to args, which makes these arguments available to the code that executes within main(). You’ll learn about parameters and arguments in Chapter 3.

main() is called with an array of strings (character sequences) that identify the application’s command-line arguments. These strings are stored in String-based array variable args. (I discuss method calling, arrays, and variables in Chapters 2 and 3.) Although the array variable is named args, there is nothing special about this name. You could choose another name for this variable.

The block of code first executes System.out.println("Passed arguments:");, which calls System.out’s println() method with the "Passed arguments :" string. This string is written to the standard output stream.

From left to write, System identifies a standard class of system utilities; out identifies an object variable located in System whose methods let you output values of various types optionally followed by a newline character to the standard output stream; println identifies a method that prints its argument followed by a newline character to standard output; and "Passed arguments:" is a string (a sequence of characters delimited by double quote " characters and treated as a unit) that is passed as the argument to println and written to standard output (the starting " and ending " double quote characters are not written; these characters delimit but are not part of the string).

The block of code next uses a for loop to repeatedly execute System.out.println(args[i]);. The loop executes args.length times, or once for each string stored in args. (I discuss for loops and .length in Chapter 2.)

The System.out.println(args[i]); method call reads the string stored in the ith entry of the args array—the first entry is located at index (location) 0; the last entry is stored at index args.length - 1. This method call then outputs this string to standard output.

Assuming that you’re familiar with your platform’s command-line interface and are at the command line, make DumpArgs your current directory and copy Listing 1-1 to a file named DumpArgs.java. Then compile this source file via the following command line:

javac DumpArgs.java

Assuming that that you’ve included the .java extension, which is required by javac, and that DumpArgs.java compiles, you should discover a file named DumpArgs.class in the current directory. Run this application via the following command line:

java DumpArgs

If all goes well, you should see the following line of output on the screen:

Passed arguments:

For more interesting output, you’ll need to pass command-line arguments to DumpArgs. For example, execute the following command line, which specifies Curly, Moe, and Larry as three arguments to pass to DumpArgs:

java DumpArgs Curly Moe Larry

This time, you should see the following expanded output on the screen:

Passed arguments:
Curly
Moe
Larry

You can redirect the output destination to a file by specifying the greater than angle bracket (>) followed by a filename. For example, java DumpArgs Curly Moe Larry >out.txt stores the DumpArgs application’s output in a file named out.txt.

Congratulations on successfully compiling your first application source file and running the application! Listing 1-2 presents the source code to a second application, which echoes text obtained from the standard input stream to the standard output stream.

Listing 1-2.  Echoing Text Read from Standard Input to Standard Output

public class EchoText
{
   public static void main(String[] args) throws java.io.IOException
   {
      System.out.println("Please enter some text and press Enter!");
      int ch;
      while ((ch = System.in.read() ) != −1)
         System.out.print((char) ch);
      System.out.println();
   }
}

After outputting a message that prompts the user to enter some text, main() introduces int variable ch to store each character’s integer representation. (You will learn about int and integer in Chapter 2.)

main() now enters a while loop (discussed in Chapter 2) to read and echo characters. The loop first calls System.in.read() to read a character and assign its integer value to ch. The loop ends when this value equals −1 (no more input data is available).

For any other value in ch, this value is converted to a character via (char), which is an example of Java’s cast operator (discussed in Chapter 2). The character is then output via System.out.print(), which doesn’t also terminate the current line. The final System.out.println(); call terminates the current line without outputting any content.

Compile Listing 1-2 via javac EchoText.java and run the application via java EchoText. You’ll be prompted to enter some text. After you input this text and press Enter, the text will be sent to standard output. For example, consider the following output:

Please enter some text and press Enter!
Hello Java
Hello Java

You can redirect the input source to a file by specifying the less than angle bracket (<) followed by a filename. For example, java EchoText <EchoText.java reads its text from EchoText.java and outputs this text to the screen.

As well as downloading and installing the JDK, you’ll need to access the JDK documentation, especially to explore the Java APIs. There are two sets of documentation that you can explore:

• Oracle’s JDK 7 documentation (http://docs.oracle.com/javase/7/docs/api/index.html)
• Google’s Java API documentation (https://developer.android.com/reference/packages.html)

Oracle’s JDK 7 documentation presents many APIs that are not supported by Android. Furthermore, it doesn’t cover APIs that are specific to Android. This book focuses only on Java APIs that are covered in Google’s documentation.

Installing and Exploring the Eclipse IDE

Working with the JDK’s tools at the command line is probably okay for small projects. However, this practice is not recommended for large projects, which are hard to manage without the help of an IDE.

An IDE consists of a project manager for managing a project’s files, a text editor for entering and editing source code, a debugger for locating bugs, and other features. Eclipse is a popular IDE that Google supports for developing Android apps.

EclipseIDE is an open source IDE for developing programs in Java and other languages (e.g., C, COBOL, PHP, Perl, and Python). Eclipse Classic is one distribution of this IDE that is available for download; version 4.2.1 is the current version at time of writing.

You should download and install Eclipse Classic to follow along with this section’s Eclipse-oriented example. Begin by pointing your browser to www.eclipse.org/downloads/ and accomplishing the following tasks:

1. Scroll down the page until you see an Eclipse Classic entry. (It may refer to 4.2.1 or a newer version.)
2. Click one of the platform links (e.g., Windows 32 Bit) to the right of this entry.
3. Select a download mirror from the subsequently displayed page and proceed to download the distribution’s archive file.

I downloaded the approximately 183 MB eclipse-SDK-4.2.1-win32-x86_64.zip archive file for my Windows 7 platform, unarchived this file, moved the resulting eclipse home directory to another location, and created a shortcut to that directory’s eclipse.exe file.

After installing Eclipse Classic, run this application. You should discover a splash screen identifying this IDE and a dialog box that lets you choose the location of a workspace for storing projects, followed by a main window like that shown in Figure 1-1.

Click the OK button and you’re taken to Eclipse’s main window. See Figure 1-2.

The main window initially presents a Welcome tab from which you can learn more about Eclipse. Click this tab’s X icon to close this tab; you can restore the Welcome tab by selecting Welcome from the menubar’s Help menu.

The Eclipse user interface is based on a main window that consists of a menubar, a toolbar, a workbench area, and a statusbar. The workbench presents windows for organizing Eclipse projects, editing source files, viewing messages, and more.

To help you get comfortable with the Eclipse user interface, I’ll show you how to create a DumpArgs project containing a single DumpArgs.java source file with Listing 1-1’s source code. You’ll also learn how to compile and run this application.

Complete the following steps to create the DumpArgs project:

1. Select New from the File menu and Java Project from the resulting pop-up menu.
2. In the resulting New Java Project dialog box, enter DumpArgs into the Project name text field. Keep all the other defaults and click the Finish button.

After the second step, you’ll see a workbench similar to that shown in Figure 1-3.

On the left side of the workbench, you see a window titled Package Explorer. This window identifies the workspace’s projects in terms of packages (discussed in Chapter 5). At the moment, only a single DumpArgs entry appears in this window.

Clicking the triangle icon to the left of DumpArgs expands this entry to reveal src and JRE System Library items. The src item stores the DumpArgs project’s source files, and the JRE System Library identifies various JRE files that are used to run this application.

You’ll now add a new file named DumpArgs.java to src, as follows:

1. Highlight src and select New from the File menu and File from the resulting pop-up menu.
2. In the resulting New File dialog box, enter DumpArgs.java into the File name text field, and click the Finish button.

Eclipse responds by displaying an editor window titled DumpArgs.java. Copy Listing 1-1 content to this window. Then compile and run this application by selecting Run from the Run menu. (If you see a Save and Launch dialog box, click OK to close this dialog box.) Figure 1-4 shows the results.

You must pass command-line arguments to DumpArgs to see additional output from this application. Accomplish this task as follows:

1. Select Run Configurations from the Run menu.
2. In the resulting Run Configurations dialog box, select the Arguments tab.
3. Enter Curly Moe Larry into the Program arguments text area and click the Close button.

Once again, select Run from the Run menu to run the DumpArgs application. This time, the Console tab reveals Curly, Moe, and Larry on separate lines below “Passed arguments:”.

This is all I have to say about the Eclipse IDE. For more information, study the tutorials via the Welcome tab, access IDE help via the Help menu, and explore the Eclipse documentation at www.eclipse.org/documentation/.

Overview of Java APIs

Oracle organizes its standard class library APIs into packages (see Chapter 5), which are analogous to file folders. Similarly, Google organizes its Android-oriented standard class library APIs into packages. In this section, I provide an overview of various Java APIs that are common to Oracle and Google. Furthermore, I discuss (throughout this book) only those APIs that are located in both libraries. By limiting my discussion to common APIs, I avoid discussing Java APIs that cannot be used when creating Android apps.

Summary

Java is a language and a platform. The language is partly patterned after the C and C++ languages to shorten the learning curve for C/C++ developers. The platform consists of a virtual machine and associated execution environment.

Developers use different editions of the Java platform to create Java programs that run on desktop computers, web browsers, web servers, mobile information devices, and embedded devices. These editions are known as Java SE, Java EE, and Java ME.

Developers also use a special Google-created edition of the Java platform to create Android apps that run on Android-enabled devices. This edition, known as the Android platform, presents a Dalvik virtual machine that runs on top of a specially modified Linux kernel.

The public JRE implements the Java SE platform and makes it possible to run Java programs. The JDK provides tools (including the Java compiler) for developing Java programs and also includes a private copy of the JRE.

Working with the JDK’s tools at the command line is not recommended for large projects, which are hard to manage without the help of an integrated development environment. Eclipse is a popular IDE that Google supports for developing Android apps.

Oracle organizes its standard class library APIs into packages, which are analogous to file folders. Similarly, Google organizes its Android-oriented standard class library APIs into packages. In this chapter I also presented an overview of some of these packaged APIs.

Chapter 2 starts to introduce you to the Java language by focusing on this language’s fundamentals. You’ll learn about comments, identifiers, types, variables, expressions, statements, and more.