The Java Development Kit

The Java Development Kit is a software package that contains tools that allow developers, like you, to write new Java programs. These tools include things like the Java compiler, which converts the code you write into bytecode that the Java Virtual Machine can read, as well as the JVM itself and tools that allow you to package your creations to distribute to other users.

There are two basic versions of the JDK, both maintained and distributed by Oracle: OpenJDK and Oracle JDK. OpenJDK is the open source reference implementation of the JDK. This means that it is the standard from which all other JDK implementations are derived. OpenJDK is released under the GPL v2 license and is completely open to the community. It contains the core code that makes Java work.

The Oracle JDK is based on OpenJDK, but it is a commercial implementation released under the Oracle Binary Code License Agreement.

The two versions have nearly identical code, but the Oracle JDK has a few more classes (some closed source) and some additional bug fixes. Businesses generally use the Oracle JDK because it tends to be a bit more stable; however, most Oracle JDK versions are distributed under a relatively restricted license. You can download the software for free, but you are only allowed to use the free version for personal, noncommercial projects. The free Oracle JDK license excludes the ability to create software that you want to sell or distribute for others to use. Many businesses choose to pay for commercial-use licenses because Oracle Java JDK includes support features not included in the open source versions.

We include instructions in the following sections to install OpenJDK for use in this course. You are welcome to use Oracle JDK instead, if you prefer. We use the open source OpenJDK here because it is completely free for any purpose you want to use it for, including creating and selling your own software packages. While Oracle does allow developers to use its Java JDK at no cost for personal projects, the free license does not allow commercial use. Many businesses choose to purchase licenses for Oracle's Java JDK to take advantage of the additional support that Oracle provides with the commercial version. However, because the JDK is very much behind the scenes when developing software using Java, you are not likely to notice much difference between the two.

The Java Virtual Machine

One of the problems with writing software today is that we normally want our programs to be compatible with as many different types of computers as possible. What good is a killer app if it will run on only one brand of smartphone? What about a custom enterprise application that will run only on a Windows machine, even though many employees may use Apple computers? This is where Java has an advantage over other coding languages.

The Java Virtual Machine (JVM) is a software layer between the Java code and the machine running the software. A virtual machine (VM) is essentially a piece of software that acts like a computer, and it performs many of the same input/process/output operations that a physical computer does.

Essentially, the JVM (which is included in the JDK) acts as a translator between the compiled Java code and the machine's bytecode. This means that our program will run on any computer that the JVM recognizes, so we can write one app that will work on many different devices, rather than writing multiple versions of the same app for different platforms. The result is that we can write once and run anywhere, a process Sun Microsystems named WORA to promote the use of Java.

The Java Runtime Environment

As a Java developer, you may also hear about the Java Runtime Environment (JRE). Through Java version 8, anyone who wanted to run a Java application on their computer had to first install a compatible JRE, which included the JVM required to run compiled software but did not include the tools used to develop software.

Starting with Java 9, however, the JDK includes a packaging process that creates an executable package that does not require a separate JRE on the end user's computer. This streamlines the distribution process a bit, making it even easier to write once and run anywhere when we use Java.

Java 8 is still widely used in many enterprises, however, so it's not impossible that you will run across the need to have a JRE installed to run software written in Java.

Installing OpenJDK on Microsoft Windows

The following instructions walk you through checking for an existing copy of the JDK on Microsoft Windows 10. You'll then install and verify an installation of OpenJDK. If you are using macOS, skip ahead to the next section.

Checking for an Existing JDK on Windows

Start by checking to see whether you already have a JDK installed. This can be done by opening a command prompt window and using the command line.

You can open a command prompt window by clicking the Start menu, searching for cmd, and selecting Command Prompt in the search results. Figure 1.1 shows how to use the Windows Search box to find the command prompt window.

In the command prompt window, key the following command as shown in Figure 1.2:

java -version

Windows will display the current version of Java installed on your computer. In this screenshot, the results are as follows:

openjdk version "11.0.7" 2020-04-14
OpenJDK Runtime Environment AdoptOpenJDK (build 11.0.7+10)
OpenJDK 64-Bit Server VM AdoptOpenJDK (build 11.0.7+10, mixed mode)

If your results are similar to those displayed in Figure 1.2 and you see openjdk with a version number that starts with 11, you already have the correct version of OpenJDK on your computer, and you can skip to “Creating Your Java First Program.”

In the rare case that Java is not installed, you might see a message such as this:

'java' is not recognized as an internal or external command,
operable program or batch file.

If you get this message, simply continue to the next section for installing OpenJDK.

Installing OpenJDK

If you don't have the latest version—or any version—then you'll need to install the OpenJDK. Use your browser to navigate to AdoptOpenJDK.net, as shown in Figure 1.3.

Verify that the page has identified your computer platform (e.g., Windows, macOS, or Linux) correctly and select OpenJDK 11 with the Hotspot JVM. Click the Latest release button and save the file to a known location on your computer.

Open or run the saved file. If prompted as shown in Figure 1.4, confirm that you want to launch the installer.

The installer will launch the setup wizard to install the AdoptOpenJDK JDK, as shown in Figure 1.5.

You should verify that it will install JDK 11 and click Next. This will show the end-user license agreement, as shown in Figure 1.6.

The license on AdoptOpenJDK is a GNU General Public License, which means that it is open source, and anyone can use it in any way, as long as credit is given to the original developers. Accept the license agreement and click Next. This will display the Custom Setup settings, as shown in Figure 1.7.

Accept the default settings in the Custom Setup window. You should note the location where the JDK will be installed in this window. You will need it later.

Click Next to be taken to a window similar to Figure 1.8.

Click Install to begin the actual installation of the JDK. Windows will ask if you want to allow the app to make changes to your account (Figure 1.9). Click Yes.

The installation will start and run automatically (Figure 1.10). The installation will take several minutes to complete.

You will see a confirmation window when the installation is complete (Figure 1.11).

Verifying the Installation

Verify that you have Java 11 installed on your computer. Follow the same steps you did earlier to see what version you had installed. Open a command-line window by clicking the Start menu, searching for cmd, and selecting Command Prompt in the search results. This was shown in Figure 1.1.

As shown in Figure 1.2, type the following command into the command prompt window:

java -version

Windows will confirm that Java is installed by returning the version number. We show this again in Figure 1.12. You should now see a version that starts with 11 as the first number in the version number. We are now ready start working with the Java and the JDK.

Installing OpenJDK on macOS

The following instructions walk you through checking for an existing copy of the JDK on macOS. You'll then install and verify an installation of OpenJDK. If you are using Windows, skip ahead to the next section to see how to use the JDK with a Java program.

java -version

openjdk version "11.0.3" 2019-04-16
OpenJDK Runtime Environment AdoptOpenJDK (build 11.0.3+7)
OpenJDK 64-Bit Server VM AdoptOpenJDK (build 11.0.3+7, mixed mode)

Installing OpenJDK

Use your browser to navigate to AdoptOpenJDK.net. You should see a page similar to what is presented in Figure 1.14.

Verify that AdoptOpenJDK recognizes your operating system as macOS x64. Select OpenJDK 11 on the left and Hotspot on the right and then click Latest release. In Figure 1.14, the file is jdk-11.0.3+7, but you may see a slightly different version number. As long as the first number is 11, it's fine.

Your browser will download the file. Open the saved file after the download is complete to start the Installer. This should display a dialog similar to Figure 1.15.

Click Continue to start the installer. When prompted, you must accept the license agreement, as shown in Figure 1.16.

Click Agree and then click Continue. You'll be taken to the dialog shown in Figure 1.17 that shows that, by default, the files will be installed on the computer's main disk.

You can change the location if you want, but most users should use the default setting. Click Install to continue. This will start the installation. When the installation is completed, you will see a confirmation similar to Figure 1.18.

Click Close to complete the process.

Verifying the Installation

Confirm the version of Java installed on your computer by opening Terminal (using Spotlight Search or Launch Pad) as you did before and entering the following command:

java -version

You should see results similar to what are shown in Figure 1.19. The results are as follows:

openjdk version "11.0.3 " 2019-04-16
OpenJDK Runtime Environment AdoptOpenJDK (build 11.0.3+7)
OpenJDK 64-Bit Server VM AdoptOpenJDK (build 11.0.3+7, mixed mode)

If you see openjdk version 11 in the results, you are ready to go to the next step.

Writing the Program

When learning a new language, it is customary that your first program simply print out “Hello, World!” to the screen. We'll do this following these steps:

1. Open a text editor.
2. Type in the Java code.
3. Save the file as Hello.java.
4. Compile the code with the Java compiler (javac).
5. Run the program.

Open a text editor on your computer. For Windows, Notepad is a good choice; however, you can use any text editor you like. If you have a Mac, you can use the text editor. On Linux, there are editors such as Gedit, nano, or Vi. Create a new file if necessary and then type the code presented in Listing 1.1. Don't worry about what any of it means; we'll get to that soon enough.

LISTING 1.1

Hello.java: “Hello, World!”

public class Hello {
    public static void main (String[] args) {
        System.out.println("Hello, World!");
    }
}

There are several things to notice about this file. First, you should note that the program creates something called a public class in the first line. A Java program is a class, which is a basic container for code in Java. This public class has the name Hello. It is important that when you enter this program into your editor and save it, you use this same name for the file. As such, you will need to save the program as Hello.java. If you are using a text editor in Windows, you'll want to make sure that .txt doesn't get added to the end of the name.

In addition to a Java program being a class, this class will also have a main method in it. A method is another container for Java code. A method must be placed inside a class. It is a named block of code that can be executed to accomplish some task. Here, it just prints “Hello, World!” You will learn more about classes and methods in future lessons.

The main method is a special method that is the entry (or starting) point for every Java program. The first line of the main method (public static void main (String[] args)) must be written exactly as in Listing 1.1, and it must be contained inside a class.

The curly braces, { }, denote the beginning and ending, respectively, of code blocks. You'll see that there are two sets of curly braces in our program. One is nested inside the other.

This leaves one more big line of code to mention:

System.out.println("Hello, World!"); 

This line is the magic code that sends things to the console. In this case, this code is going to write what is between the two quotes to the console. We'll learn much more about this later. For now, make sure you include the periods and the semicolon where they are shown in this line of code. You also need to make sure you capitalize the word System as shown. These small details are important for making sure the program works as expected.

Compiling and Running the Program

Now that you've written the Java program, you are ready to compile and run it.

To be able to run the program, we need to convert it into what is known as a class file. That class file contains what is known as bytecode. It is bytecode that the Java runtime environment, in particular the Java virtual machine, is able to interpret and run as our program. To do that, we can run the Java compiler.

To run the Java compiler, we type in javac. That's the name of the program. Javac is looking for one or more Java files to compile. In our case, we just want to pass in Hello.java. When we do this, the compiler will read Hello.java, and it will convert that into a class file called Hello.class.

Open your command-line interface and use the cd command to open the directory where you saved the Hello.java file. You saw how to open the command-line interface earlier to check the version of your JDK.

• In Windows, click Start and use cmd to open the command prompt.
  • Enter cd Documents and hit Enter.
  • Enter dir at the prompt and verify that you see Hello.java in the results.
• In Mac (or Linux), open Terminal.
  • Enter cd Documents and hit Enter.
  • Enter ls at the prompt, hit Enter, and verify that you see Hello.java in the results.

We will now compile our program by running the following command on the command line:

javac Hello.java

When you run this command, it will compile your code and create a Java program that can be executed. If you entered everything correctly, you won't see any feedback. If you entered something wrong, then any errors will be displayed. If an error is displayed, review the code in Listing 1.1 and make sure what you typed into your editor is identical, including semicolons and periods.

After our program is compiled, we can run it. We need to tell Java what program to execute. We'll run the Java program by using the java command on the command line followed by the name of the class we are running, in this case, Hello.

java Hello

Note that we did not include any extension, but rather just use the name of the class we are running. When this command is executed, it will print “Hello, World!” to the screen, as shown in Figure 1.20.

Dealing with Syntax Errors

Syntax is the sequence of characters that make up well-formed statements in a programming language. You can think of syntax like the spelling, punctuation, and grammar rules of the programming language. The compiler is good at detecting syntax errors and will tell you when you type something that is not syntactically correct.

If you make a mistake in your program by leaving off a punctuation mark, capitalizing something that shouldn't be capitalized, or forgetting a bracket, it can cause a syntax error. If you entered Listing 1.1 perfectly, then it would have compiled without any issues. If, however, you made a mistake, then you might have gotten feedback.

Remove the semicolon from the end of the following line in Listing 1.1:

System.out.println("Hello, World!")

If you compile the listing again, the following is the output you'll receive:

C:UsersJavaStudentjava>javac Hello.java
Hello.java:3: error: ';' expected
        System.out.println("Hello, World!")
                                           ^
1 error

As you can see, the Java compiler is providing you with information on your syntax error. This will help you determine what needs to be fixed.