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 in order to shorten the learning curve for C/C++ developers.

You’ll learn about single-line, multiline, and Javadoc comments in Chapter 2. Also, you’ll learn about reserved words, primitive types, operators, blocks, and statements 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 (storage locations 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.)

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, and it is commonly referred to as the Java virtual machine (JVM) . The execution environment consists of libraries for running programs and interacting with the underlying operating system (also known as the native platform).

The execution environment includes a huge library of prebuilt class files 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 object code consisting of instructions that are executed by the JVM and associated data. These instructions are known as bytecode . Figure 1-1 shows this translation process.

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

A Java program executes via a tool that loads and starts the JVM and passes the program’s main class file to the machine. The JVM uses its classloader component to load the class file into memory.

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

Assuming that all is well with the class file’s bytecode, the JVM’s interpreter component 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 JVM’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 class file’s bytecode. When that happens, it asks the classloader to load the class file and the bytecode verifier to verify the bytecode before executing that bytecode.

Also during execution, bytecode instructions might request that the JVM open a file, display something on the screen, or perform another task that requires cooperation with the native platform. The JVM responds by transferring the request to the platform via its Java Native Interface (JNI) bridge to the native platform. Figure 1-2 shows these JVM tasks.

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, Linux, Mac OS X, and other platforms.

The platform side of Java also promotes security by doing its best to provide a secure environment (such as 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 and Java EE

This book largely focuses on Java SE and applications.

Hello, World!

It’s customary to start exploring a new language and its tools by writing, compiling, and running a simple application that outputs the “Hello, World!” message. This practice dates back to Brian Kernighan’s and Dennis Ritchie’s seminal book, The C Programming Language.

This short five-line application has a lot to say about the Java language. We’ll briefly explain each feature, leaving comprehensive discussions of these features to later chapters.

This source code declares a class, which you can think of as a container for describing an application. The first line, public class HelloWorld, introduces the name of the class (HelloWorld), which is preceded by reserved words (names that have meaning to the Java compiler and which you cannot use to name other things in your programs) public and class. These reserved words respectively tell the compiler that HelloWorld must be stored in a file named HelloWorld and that a class is being declared.

The rest of the class declaration appears between a pair of brace characters ({}), which are familiar to C and C++ developers. Between these characters is the declaration of a single method, which you can think of as a named sequence of code. This method is named main to signify that it’s the entry point into the application, and it is the analog of the main() function in C and C++.

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

DumpArgs

Listing 1-2’s DumpArgs application consists of a class named DumpArgs that’s very similar to Listing 1-1’s HelloWorld class. The essential difference between these classes is the for loop (a construct for repeated execution and starting with reserved word for) that accesses each array item and dumps it to the standard output stream.

The for loop first initializes integer variable i to 0. This variable keeps track of how far the loop has progressed (the loop must end at some point), and it also identifies one of the entries in the args array. Next, i is compared with args.length, which records the number of entries in the array. The loop ends when i’s value equals the value of args.length. (We discuss .length in Chapter 2.)

Each loop iteration executes System.out.println(args[i]) ;. The string is 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 and is accessed and then output to the standard output stream. Finally, i is incremented by 1 via i++, and i < args.length is reevaluated to determine whether the loop continues or ends.

EchoText

EchoText is a more complex application than HelloWorld or DumpArgs. Its main() method first declares a Boolean (true/false) variable named isRedirect that tells this application whether input originates from the keyboard (isRedirect is false) or a file (isRedirect is true). The application defaults to assuming that input originates from the keyboard.

There’s no easy way to determine if standard input has been redirected, and so the application requires that the user tell it if this is the case by specifying one or more command-line arguments. The if decision (a construct for making decisions and starting with reserved word if) evaluates args.length != 0, assigning true to isRedirect when this Boolean expression evaluates to true (at least one command-line argument has been specified).

main() now introduces the int variable ch to store the integer representation of each character read from standard input. (You’ll learn about int and integer in Chapter 2.) It then enters a sequence of code prefixed by the reserved word try and surrounded by brace characters. Code within this block may throw an exception (an object describing a problem) and the subsequent catch block will handle it (to address the problem). (We discuss exceptions in Chapter 5.)

The try block consists of a while loop (a construct for repeated execution and starting with the reserved word while) that reads and echoes 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 from a file; standard input was redirected) or ' ' (the newline/line feed character) has been read, which is the case when standard input wasn’t redirected. ' ' is an example of a character literal, which is discussed in Chapter 2.

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 by outputting a newline. The final System.out.println() ; call terminates the current line without outputting any content.

When standard input is redirected to a file and System.in.read() is unable to read text from the file (perhaps the file is stored on a removable storage device that has been removed before the read operation), System.in.read() fails by throwing a java.io.IOException object that describes this problem. The code within the catch block is then executed, which outputs an I/O error message to the standard error stream via System.err.println("I/O error");.

You should see this text duplicated on the following line and the application should end.

Although it looks like there are two command-line arguments, there is only one: x. (Redirection symbols followed by file names don’t count as command-line arguments.) You should observe the contents of EchoText.java listed on the screen.

This time, x isn’t specified, so input is assumed to originate from the keyboard. However, because the input is actually coming from the file EchoText.java, and because each line is terminated with a newline, only the first line from this file will be output.

What Is Android?

Android is Google’s software stack for mobile devices. This stack consists of apps (such as Browser and Contacts), a virtual machine in which apps run, middleware (software that sits on top of the operating system and provides various services to the virtual machine and its apps), and a Linux-based operating system.

Although not part of the software stack, Android’s rich development environment provided by Android Studio could also be considered an Android feature.

History of Android

Contrary to what you might expect, Android didn’t originate with Google. Instead, Android, Inc., a small Palo Alto, California-based startup company, initially developed Android. Google bought this company in the summer of 2005 and released a beta version of the Android SDK in November 2007.

On September 23, 2008, Google released Android 1.0, whose core features included a web browser, camera support, Google Search, Wi-Fi and Bluetooth support, and more. This release corresponds to API Level 1. (An API level is a 1-based integer that uniquely identifies the API revision offered by an Android version; it’s a way of distinguishing one significant Android release from another.)

Android Architecture

The Android software stack consists of apps at the top, a Linux kernel with various drivers at the bottom, and middleware (an application framework, libraries, and the Android runtime) in the center. Figure 1-7 shows this layered architecture.

Users care very much about apps, and Android ships with a variety of useful core apps, which include Browser, Contacts, and Phone. All apps are written in the Java programming language. Apps form the top layer of Android’s architecture.

Android doesn’t officially recognize Java language features newer than Java 8, which is why we don’t discuss them in this book. Regarding APIs, this platform supports many APIs from Java 8 and previous Java versions. Also, Android provides its own unique APIs.

Android provides a runtime environment that consists of core libraries (implementing a subset of the Apache Harmony Java version 5 implementation) and the ART virtual machine (a non-JVM).

Each Android app defaults to running in its own Linux process (executing application) , which hosts an instance of ART. This virtual machine has been designed so that devices can run multiple virtual machines efficiently.

Perhaps you’re wondering how it’s possible to have a non-JVM run Java code. The answer is that ART doesn’t run Java code. Instead, Android transforms compiled Java class files into a special ART binary format, and it’s this resulting code that gets executed by ART.

Finally, the libraries and Android runtime rely on the Linux kernel for underlying core services, such as threading, low-level memory management, a network stack, process management, and a driver model. Furthermore, the kernel acts as an abstraction layer between the hardware and the rest of the software stack.

Android Says Hello

Listing 1-4 isn’t too different from Listing 1-1, but there are some significant changes. For one thing, HelloWorld extends another class named Activity (stored in a package named android.app—see Chapter 5 for a discussion of packages). By extending Activity, HelloWorld proclaims itself as an activity, which you can think of as a user interface screen. (We discuss extension in Chapter 4.)

By extending Activity, HelloWorld inherits that class’s create() method, which Android calls when creating the activity. HelloWorld overrides this method with its own implementation so that it can output the “Hello, World!” message. However, create() first needs to execute Activity’s version of this method (via super.onCreate()), so that the activity is properly initialized.

HelloWorld, DumpArgs, and EchoText demonstrate public staticvoid main(String[] args) as a Java application’s entry point. This is where the application’s execution begins. In contrast, as you’ve just seen, an Android app doesn’t require this method for its entry point because the app’s architecture is very different.