Platform independence

One of the main reasons Java is so popular is its platform independence, which simply means that Java programs can be run on many types of computers. A Java program runs on any computer with a Java Runtime Environment, also known as a JRE, installed. A JRE is available for almost every type of computer you can think of: PCs running any version of Windows, Macintosh computers, Unix and Linux computers, huge mainframe computers, and even cellphones.

Before Java, other programming languages promised platform independence by providing compatible compilers for different platforms. (A compiler is the program that translates programs written in a programming language into a form that can actually run on a computer.) The idea was that you could compile different versions of the programs for each platform. Unfortunately, this idea never really worked. The compilers were never identical on each platform; each had its own little nuances. As a result, you had to maintain a different version of your program for each platform you wanted to support.

Java’s platform independence isn’t based on providing compatible compilers for different platforms. Instead, Java is based on the concept of a virtual machine. You can think of the Java Virtual Machine (sometimes called the JVM) as being a hypothetical computer platform — a design for a computer that doesn’t exist as actual hardware. Instead, the JRE is an emulator — a program that sets aside part of your hard drive to act like a computer (namely, the JVM) that can execute Java programs.

The Java compiler doesn’t translate Java into the machine language of the computer that the program is running on. Instead, the compiler translates Java into the machine language of the JVM, which is called bytecode. Then the JRE runs the bytecode in the JVM. Because of the JVM, you can execute a Java program on any computer that has a JRE installed without recompiling the program.

That’s how Java provides platform independence — and believe it or not, it works pretty well. The programs you write run just as well on a PC running any version of Windows, a Macintosh, a Unix or Linux machine, or any other computer with a JRE installed — including smartphones or tablet computers.

While you lie awake tonight pondering the significance of Java’s platform independence, here are a few additional thoughts to ponder:

• The JRE is separate from the Java compiler. As a result, you don’t have to install a Java compiler to run compiled Java programs. All you need is the JRE.
• When someone asks whether your computer “has Java,” he or she usually means to ask, “Have you installed the Java Runtime Environment?” (You need the JRE so that you can run Java programs.)

• Platform independence goes only so far. If you have some obscure type of computer system — such as an antique Olivetti Programma 101 — and a JRE isn’t available for it, you can’t run Java programs on it.

  I didn’t make up the Olivetti Programma 101. It was a desktop computer made in the early 1960s, and it happened to be my introduction to computer programming. (My junior high school math teacher had one in the back of his classroom, and he let me play with it during lunch.) Do a Google search for Olivetti Programma 101 and you can find several interesting websites about it.

• Java’s platform independence isn’t perfect. Although the bytecode runs identically on every computer that has a JRE, some parts of Java use services provided by the underlying operating system. As a result, minor variations sometimes crop up, especially in applications that use graphical interfaces.
• Because a runtime system that emulates a JVM executes Java bytecode, some people mistakenly compare Java with interpreted languages such as Basic or Perl. Those languages aren’t compiled at all, however. Instead, the interpreter reads and interprets each statement as it is executed. Java is a true compiled language; it’s just compiled to the machine language of JVM rather than to the machine language of an actual computer platform.

• If you’re interested, the JVM is completely stack-oriented; it has no registers for storing local data. (I’m not going to explain what that term means, so if it doesn’t make sense to you, skip it. It’s not important. It’s just interesting to nerds who know about stacks, registers, and things of that ilk.)

Object orientation

Java is inherently object-oriented, which means that Java programs are made up from programming elements called objects. Simply put (don’t you love it when you read that in a computer book?), an object is a programming entity that represents either some real-world object or an abstract concept.

All objects have two basic characteristics:

• Objects have data, also known as state. An object that represents a book, for example, has data such as the book’s title, author, and publisher.
• Objects also have behavior, which means that they can perform certain tasks. In Java, these tasks are called methods. An object that represents a car might have methods such as start, stop, drive, and crash. Some methods simply allow you to access the object’s data. A book object might have a getTitle method that tells you the book’s title.

Classes are closely related to objects. A class is the program code you write to create objects. The class describes the data and methods that define the object’s state and behavior. When the program executes, classes are used to create objects.

Suppose you’re writing a payroll program. This program probably needs objects to represent the company’s employees. So the program includes a class (probably named Employee) that defines the data and methods for each Employee object. When your program runs, it uses this class to create an object for each of your company’s employees.

The Java API

The Java language itself is very simple, but Java comes with a library of classes that provide commonly used utility functions that most Java programs can’t do without. This class library, called the Java API (short for application programming interface), is as much a part of Java as the language itself. In fact, the real challenge of finding out how to use Java isn’t mastering the language; it’s mastering the API. The Java language has only about 50 keywords, but the Java API has several thousand classes, with tens of thousands of methods that you can use in your programs.

The Java API has classes that let you do trigonometry, write data to files, create windows onscreen, and retrieve information from a database, among other things. Many of the classes in the API are general purpose and commonly used. A whole series of classes stores collections of data, for example. But many are obscure, used only in special situations.

Fortunately, you don’t have to learn anywhere near all of the Java API. Most programmers are fluent with only a small portion of it: the portion that applies most directly to the types of programs they write. If you find a need to use some class from the API that you aren’t yet familiar with, you can look up what the class does in the Java API documentation at http://download.java.net/jdk9/docs/api.

The Internet

Java is often associated with the Internet, and rightfully so, because Al Gore invented Java just a few days after he invented the Internet. Okay, Java wasn’t really invented by Al Gore. It was developed right at the time the World Wide Web was becoming a phenomenon, and Java was specifically designed to take advantage of the web. In particular, the whole concept behind the JVM is to enable any computer connected to the Internet to run Java programs, regardless of the type of computer or the operating system it runs.

You can find three distinct types of Java programs on the Internet:

• Servlets: Servlets are web-based Java programs that run on an Internet server computer rather than in an Internet user’s web browser. Servlets are the real way that many, if not most, commercial websites work. A servlet generates a page of HTML that is sent to a user’s computer to be displayed in the user’s web browser. If you request information about a product from an online store, the store’s web server runs a servlet to generate the HTML page containing the product information you requested.
• Applets: Applets are Java programs that run directly within a web browser. To run an applet, the browser starts a JVM, and that virtual machine is given a portion of the web page to work with. Then the virtual machine runs the applet’s bytecode.
• Web Start applications: A Web Start is a Java application that is designed to be launched from a web page but run directly on a user’s computer rather than within a web browser.

Applets have recently fallen out of favor because they often experience compatibility problems with different browser versions. As a result, Web Start applications have largely replaced Applets. You’ll find out how to create servlets and Web Start applications in Book 7.

Type checking

All programming languages must deal in one way or the other with type checking — the way that a language handles variables that store different types of data. Numbers, strings, and dates, for example, are commonly used data types available in most programming languages. Most programming languages also have several types of numbers, such as integers and real numbers.

All languages must check data types, so make sure that you don’t try to do things that don’t make sense (such as multiplying the gross national product by your last name). The question is, does the language require you to declare every variable’s type so you can do type checking when it compiles your programs, or does the language do type checking only after it runs your program?

Some languages, such as Pearl, are not as rigid about type checking as Java. For example, Pearl does not require that you indicate whether a variable will contain an integer, a floating point number, or a string. Thus, all the following statements are allowed for a single variable named $a:

$a = 5
$a = "Strategery"
$a = 3.14159

Here three different types of data — integer, string, and double — have been assigned to the same variable.

Java, on the other hand, does complete type checking at runtime. As a result, you must declare all variables as a particular type so that the compiler can make sure you use the variables correctly. The following bit of Java code, for example, won’t compile:

int a = 5;
String b = "Strategery";
String c = a * b;

If you try to compile these lines, you get an error message saying that Java can’t multiply an integer and a string.

In Java, every class you define creates a new type of data for the language to work with. Thus, the data types you have available to you in Java aren’t just simple predefined types, such as numbers and strings. You can create your own types. If you’re writing a payroll system, you might create an Employee type. Then you can declare variables of type Employee that can hold only Employee objects. This capability prevents a lot of programming errors. Consider this code snippet:

Employee newHire;
newHire = 21;

This code creates a variable (newHire) that can hold only Employee objects. Then it tries to assign the number 21 to it. The Java compiler won’t let you run this program because 21 is a number, not an employee.

An important object-oriented programming feature of Java called inheritance adds an interesting — and incredibly useful — twist to type checking. Inheritance is way too complicated to dive into just yet, so I’ll be brief here: In Java, you can create your own data types that are derived from other data types. Employees are people, for example, and customers are people too, so you might create a Person class and then create Employee and Customer classes that both inherit the Person class. Then you can write code like this:

Person p;
Employee e;
Customer c;
p = e; // this is allowed because an Employee is also a
    Person.
c = e; // this isn't allowed because an Employee is not a
    Customer.

Confused yet? If so, that’s my fault. Inheritance is a pretty heady topic for Chapter 1 of a Java book. Don’t panic if it makes no sense just yet. It will all be clear by the time you finish reading Book 3, Chapter 4, which covers all the subtle nuances of using inheritance.

Automatic memory management

Memory management is another detail that all programming languages have to deal with. All programming languages let you create variables. When you create a variable, the language assigns a portion of the computer’s memory to store the data referred to by the variable. Exactly how this memory is allocated is a detail that you usually can safely ignore, no matter which language you’re working with. But a detail that many languages do not let you safely ignore is what happens to that memory when you no longer need the data that was stored in it.

In C++ and similar languages, you must write code that explicitly releases that memory so that other programs can access it. If you don’t do this, or if you do it wrong, your program might develop a memory leak. In a memory leak, your program slowly but surely sucks memory away from other programs until the operating system runs out of memory and the computer grinds to a halt.

In Java, you don’t have to explicitly release memory when you’re done with it; instead, memory is freed automatically when it’s no longer needed. The JVM includes a special process called the garbage collector that snoops around the virtual machine’s memory; determines when data is no longer being used; and automatically deletes that data, freeing the memory that it occupied.

A feature related to garbage collection is bounds checking, which guarantees that programs can’t access memory that doesn’t belong to them. Languages such as C and C++ don’t have this type of safety net. As a result, programming errors in C or C++ can cause one program to trample over memory that’s being used by another program, which in turn can cause your computer to crash.

Exception handling

As Robert Burns said, “The best-laid schemes o’ mice an’ men gang oft agley, an’ lea’e us nought but grief an’ pain, for promis’d joy!” When you tinker with computer programming, you’ll quickly discover what he meant. No matter how carefully you plan and test your programs, errors happen, and when they do, they threaten to bring your whole program to a crashing halt.

Java has a unique approach to error handling that’s superior to that of any other language (except C#, which just copies Java’s approach, as I mention earlier in the chapter). In Java, the JRE intercepts and folds errors of all types into a special type of object called an exception object. After all, Java is object-oriented through and through, so why shouldn’t its exception-handling features be object-oriented?

Java requires any statements that can potentially cause an exception to be bracketed by code that can catch and handle the exception. In other words, you, as the programmer, must anticipate errors that can happen while your program is running and make sure that those errors are dealt with properly. Although this necessity can be annoying, it makes the resulting programs more reliable.