How to Install JDK 11 (on

Windows, Mac OS &

Ubuntu) and Get Started
with Java Programming
The Java Development Kit (JDK), officially named "Java Platform Standard Edition"
or "Java SE", is needed for writing Java programs. The JDK is freely available from Sun
Microsystems (now part of Oracle). The mother site for JDK (Java SE)
is http://www.oracle.com/technetwork/java/javase/overview/index.html.
"JDK" or "JRE"?
JRE (Java Runtime) is needed for running Java programs. JDK (Java Development Kit),
which includes JRE plus the development tools (such as compiler and debugger), is need
for writing as well as runningJava programs. In other words, JRE is a subset of JDK. Since
you are supposed to write Java Programs, you should install JDK, which includes JRE.
JDK Versions
Reference: "Java Version History" @ https://en.wikipedia.org/wiki/Java_version_history.
1. JDK Alpha and Beta (1995): Sun Microsystem announced Java in September
23, 1995.
2. JDK 1.0 (January 1996): Originally called Oak (named after the oak tree outside
James Gosling's office). Renamed to Java 1 in JDK 1.0.2.
3. JDK 1.1 (February 1997): Introduced AWT event model, inner class, JavaBean,
JDBC, and RMI.
4. J2SE 1.2 (JDK 1.2) (December 1998): Re-branded as "Java 2" and renamed JDK to
J2SE (Java 2 Standard Edition). Also released J2EE (Java 2 Enterprise Edition) and
J2ME (Java 2 Micro Edition). Included JFC (Java Foundation Classes - Swing,
Accessibility API, Java 2D, Pluggable Look & Feel, and Drag & Drop). Also
introduced Collection Framework and JIT compiler.
5. J2SE 1.3 (JDK 1.3) (May 2000): Introduced Hotspot JVM.
6. J2SE 1.4 (JDK 1.4) (February 2002): Introduced assert statement, non-blocking
IO (nio), logging API, image IO, Java webstart, regular expression (regex) support.
7. J2SE 5.0 (JDK 5) (September 2004): Officially called 5.0 instead of 1.5. Introduced
generics, autoboxing/unboxing, annotation, enum, varargs, for-each loop, static
import.
8. Java SE 6 (JDK 6) (December 2006): Renamed J2SE to Java SE (Java Platform
Standard Edition).
9. Java SE 7 (JDK 7) (July 2011): First version after Oracle purchased Sun
Microsystem - aslo called Oracle JDK.
10. Java SE 8 (JDK 8) (LTS) (March 2014): Included support for Lambda expressions,
default and static methods in interfaces, improved collection, and JavaScript
runtime. Also integrated JavaFX graphics subsystem.
 11. Java SE 9 (JDK 9) (September 21, 2017): Introduced modularization of the JDK
(module) under project Jigsaw, the Java Shell (jshell), and more.
12. Java SE 10 (18.3) (JDK 10) (March 2018): Introduced var for type inference local
variable (similar to JavaScript). Introduced time-based release versioning with 2
releases each year, in March and September, denoted as YY.M. Removed native-
header generation tool javah.
13. Java SE 11 (18.9) (LTS) (JDK 11) (September 2018): Extended var to lambda
expression. Standardize HTTP client in java.net.http. Support TLS 1.3. Clean up
the JDK and the installation package (removed JavaFX, JavaEE, CORBA modules,
deprecated Nashorn JavaScript engine).
14. Java SE 12 (19.3) (JDK 12) (March 2019)
1. How To Install JDK on Windows
Step 0: Un-Install Older Version(s) of JDK/JRE
I recommend that you install only the latest JDK. Although you can install multiple
versions of JDK/JRE concurrently, it is messy.
If you have previously installed older version(s) of JDK/JRE, un-install ALL of them. Goto
"Control Panel" ⇒ (optional) "Programs" ⇒ "Programs and Features" ⇒ Un-install ALL
programs begin with "Java", such as "Java SE Development Kit ...", "Java SE Runtime ...",
"Java X Update ...", and etc.
Step 1: Download JDK
1. Goto Java SE download site
@ http://www.oracle.com/technetwork/java/javase/downloads/index.html.
2. Under "Java Platform, Standard Edition" ⇒ "Java SE 11.0.{x}", where {x} denotes a
fast running security-update number ⇒ Click the "Oracle JDK" "Download" button.
3. Under "Java SE Development Kit 11.0.{x}" ⇒ Check "Accept License Agreement".
4. Choose the JDK for your operating system, i.e., "Windows". Download the "exe"
installer (e.g., "jdk-11.0.{x}_windows-x64_bin.exe" - about 150MB).
Step 2: Install JDK
Run the downloaded installer (e.g., "jdk-11.0.{x}_windows-x64_bin.exe"), which
installs both the JDK and JRE.
By default, JDK is installed in directory "C:\Program Files\Java\jdk-11.0.{x}",
where {x} denotes the update number. Accept the defaults and follow the screen
instructions to install JDK.
Use your "File Explorer", navigate to "C:\Program Files\Java" to inspect the sub-
directories. Take note of your JDK installed directory, in particular, the update
number {x}, which you will need in the next step.
In the following diagram, the JDK installed directory is " C:\Program Files\Java\jdk-
11.0.1", where {x}=1.
I shall refer to the JDK installed directory as <JAVA_HOME>, hereafter, in this article.
Step 3: Include JDK's "bin" Directory in the PATH
Windows' Command Prompt (CMD) searches the current directory and the directories
listed in the PATH environment variable (or system variable) for executable programs.
JDK's programs (such as Java compiler "javac.exe" and Java runtime "java.exe") reside
in the sub-directory "bin" of the JDK installed directory. You need to include JDK's "bin"
in the PATH to run the JDK programs.
To edit the PATH environment variable in Windows 10:
1. Launch "Control Panel" ⇒ (Optional) "System and Security" ⇒ "System" ⇒ Click
"Advanced system settings" on the left pane.
2. Switch to "Advanced" tab ⇒ Click "Environment Variables" button.
3. Under "System Variables" (the bottom pane), scroll down to select variable "Path"
⇒ Click "Edit...".
4. For Newer Windows 10:
You shall see a TABLE listing all the existing PATH entries (if not, goto next step).
Click "New" ⇒ Click "Browse" and navigate to your JDK's "bin" directory, i.e.,
"c:\Program Files\Java\jdk-11.0.{x}\bin", where {x} is your installation
update number ⇒ Select "Move Up" to move this entry all the way to the TOP.
Skip the next step.
5. For Older Windows 10:
(CAUTION: Read this paragraph 3 times before doing this step! Don't push
"Apply" or "OK" until you are 101% sure. There is no UNDO!!!)
(To be SAFE, copy the content of the "Variable value" to Notepad before changing
it!!!)
In "Variable value" field, APPEND "c:\Program Files\Java\jdk-11.0.{x}\bin"
(where {x} is your installation update number) IN FRONT of all the existing
directories, followed by a semi-colon (;)to separate the JDK's bin directory from
the rest of the existing directories. DO NOT DELETE any existing entries; otherwise,
some existing applications may not run.
6. Variable name : PATH

Variable value : c:\Program Files\Java\jdk-11.0.{x}\bin;[do not delete

exiting entries...]

Step 4: Verify the JDK Installation

Launch a CMD via one of the following means:
1. Click "Search" button ⇒ Enter "cmd" ⇒ Choose "Command Prompt", or
2. Right-click "Start" button ⇒ run... ⇒ enter "cmd", or
 3. Click "Start" button ⇒ Windows System ⇒ Command Prompt

Issue the following commands to verify your JDK installation:

1. Issue "path" command to list the contents of the PATH environment variable. Check
to make sure that your JDK's "bin" is listed in the PATH.
2. path

PATH=c:\Program Files\Java\jdk-11.0.{x}\bin;[other entries...]

3. Issue the following commands to verify that JDK/JRE are properly installed and
display their version:

4. // Display the JDK version

5. javac -version
6. javac 11.0.1
7.
8. // Display the JRE version
9. java -version
10. java version "11.0.1" 2018-10-16 LTS
11. Java(TM) SE Runtime Environment 18.9 (build 11.0.1+13-LTS)

Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.1+13-LTS, mixed

mode)

Step 5: Write a Hello-World Java Program

1. Create a directory to keep your works, e.g., "d:\myProject" or "c:\myProject". Do
NOT save your works in "Desktop" or "Documents" as they are hard to locate. The
directory name shall not contain blank or special characters. Use meaningful but
short name as it is easier to type.
2. Launch a programming text editor (such as TextPad, NotePad++, Sublime Text,
Atom). Begin with a new file and enter the following source code. Save the file as
"Hello.java", under your work directory (e.g., d:\myProject).
3. /*
4. * First Java program to say Hello
5. */
6. public class Hello { // Save as "Hello.java" under "d:\myProject"
7. public static void main(String[] args) {
8. System.out.println("Hello, world!");
9. }

Step 6: Compile and Run the Hello -World Java Program

To compile the source code "Hello.java":
1. Start a CMD Shell (Search ⇒ enter "cmd" ⇒ select "Command Prompt").
2. Set the Current Drive to the drive where you saved your source file "Hello.java".
If you use drive "c", skip this step.
Else if you use drive "d", enter "d:" as follow:
3. d:

D:\xxx>
 4. Set the Current Working Directory to the directory that you saved your source file
via the cd (Change Directory) command. For example, suppose that your source file
is saved in directory "myProject".
5. cd \myProject

D:\myProject>
6. Issue a dir (List Directory) command to confirm that your source file is present in
the current directory.
7. dir
8. ......
9. xx-xxx-xx xx:xx PM 277 Hello.java

......
10. Invoke the JDK compiler "javac" to compile the source code "Hello.java".
javac Hello.java
The compilation is successful if the command prompt returns. Otherwise, error
messages would be shown. Correct the errors in your source file and re-compile.
Check "Common JDK Installation Errors", if you encounter problem compiling your
program.
11. The output of the compilation is a Java class called "Hello.class". Issue a dir (List
Directory) command again to check for the output.
12. dir
13. ......
14. xx-xxx-xx xx:xx PM 416 Hello.class
15. xx-xxx-xx xx:xx PM 277 Hello.java

......
To run the program, invoke the Java Runtime "java":
java Hello
Hello, world!

Everything that can possibly go wrong will go wrong : Read "JDK

Installation Common Errors".
Step 7: (Optional) Download JDK API Documentation, Demos and
Samples
The JDK download does not include the documentation, which needs to be downloaded
separately. In the past, I always insist that my students should have a local copy of JDK
API Documentation. But, today, you can easily access the online copy by googling "JDK
11 Documentation".
To install JDK API documentation:
1. From the Java SE download page
(@ http://www.oracle.com/technetwork/java/javase/downloads/index.html), under
"Additional Resources", look for "Java SE 11 Documentation" ⇒ Click "Download"
⇒ Check "Accept the license agreement" ⇒ Download the zip-file (e.g., "jdk-
11.0.{x}_doc-all.zip" - about 50MB).
 2. Unzip into the JDK installed directory <JAVA_HOME>. The documentation will be
unzipped into "<JAVA_HOME>\docs". Browse the JDK documentation by opening
"<JAVA_HOME>\docs\index.html".

You should also download the "JDK x Samples and Demos", and study these samples.
Step 8: (For Advanced Users Only) JDK's Source Code
Source code for JDK is provided and kept in "<JAVA_HOME>\lib\src.zip" (or
"<JAVA_HOME>\src.zip" prior to JDK 9). I strongly recommend that you to go through
some of the source files such as "String.java", "Math.java", and "Integer.java", under
"java\lang".
1.1 Using TextPad for Java Programming (on Windows)

TextPad (@ www.textpad.com) is a lightweight programming text editor for

writing toy Java programs. It can be configured to couple with the JDK, hence, bypassing
the CMD shell.

From the TextPad editor, you can invoke the JDK compiler/runtime directly via "Tools"
menu ⇒ External Tools ⇒ "Compile Java" or "Run Java Application". Take note of the
keyboard shortcuts - Ctrl+1 for compile and Ctrl+2 for run.

If you cannot find these commands in the "Tools" menu, goto "Configure" ⇒
Preferences... ⇒ Tools ⇒ Add ⇒ JDK Commands.
TextPad Tips and Configuration
Check HERE!
1.2 Using NotePad++ for Java Programming (on
Windows)
Notepad++ (@ http://notepad-plus-plus.org) is a free and open-source programming
editor.

You can use NotePad++ to write your Java source code. But you need to use CMD shell
to compile and run the Java program.
NotePad++ Customization and Tips
You can customize Notepad++ to compile and run Java programs with hot-keys. Read
"NotePad++".
1.3 How To Set the Environment Variable JAVA_HOME
Many Java applications (such as Tomcat) require the environment variable JAVA_HOME to
be set to the JDK installed directory.
To set the JAVA_HOME environment variable:
1. First, find your JDK installed directory. For JDK 11, the default is " c:\Program
Files\Java\jdk-11.0.{x}", where "{x} is the update number. Use your "File
Explorer" to find this directory and take note of your update number {x}.
2. Check if JAVA_HOME is already set. Start a CMD and issue:
set JAVA_HOME
If you get a message "Environment variable JAVA_HOME not defined", proceed to
the next step.
If you get "JAVA_HOME=C:\Program Files\Java\jdk-11.0.{x}", verify that it is
set correctly to your JDK directory. If not, proceed to the next step.
3. To set the environment variable JAVA_HOME in Windows 10:
a. Launch "Control Panel" ⇒ (Optional) "System and Security" ⇒ "System" ⇒
Click "Advanced system settings" on the left pane.
b. Switch to "Advanced" tab ⇒ Click "Environment Variables"
c. Under "System Variables" (the bottom pane) ⇒ Click "New" (or Look for
"JAVA_HOME" and "Edit" if it is already set) ⇒ In "Variable Name", enter
"JAVA_HOME" ⇒ In "Variable Value", enter your JDK installed directory you
noted in Step 1. (In the latest Windows 10: you can push the "Browse
Directory" button and navigate to the JDK installed directory to avoid typo
error.)
4. To verify, RE-START a CMD (restart is needed to refresh the environment variables)
and issue:
5. set JAVA_HOME

JAVA_HOME=c:\Program Files\Java\jdk-11.0.{x} <== Verify that this is

YOUR JDK installed directory
Notes: Windows' environment variables (such as JAVA_HOME, PATH) are NOT case-
sensitive.
2. How to Install JDK on Mac OS X
Step 1: Check if JDK has been Pre -Installed
To check if JDK has been installed, open a "Terminal" (Search "Terminal"; or Finder ⇒ Go
⇒ Utilities ⇒ Terminal) and issue this command:

javac -version
 If a JDK version number is returned (e.g., JDK x.x.x), then JDK has already been
installed. If the JDK version is prior to 1.8, proceed to Step 2 to install the latest JDK;
otherwise, proceed to "Step 3: Write a Hello-world Java program".
 If message "command not found" appears, JDK is NOT installed. Proceed to the
"Step 2: Install JDK".
 If message "To open javac, you need a Java runtime" appears, select "Install" and
follow the instructions to install JDK. Then, proceed to "Step 3: Write a Hello-world
Java program".
Step 2: Download JDK
1. Goto Java SE download site
@ http://www.oracle.com/technetwork/java/javase/downloads/index.html.
2. Under "Java Platform, Standard Edition" ⇒ "Java SE 11.0.{x}", where {x} denotes a
fast running security-update number ⇒ Click the "Oracle JDK" "Download" button.
3. Under "Java SE Development Kit 11.0.{x}" ⇒ Check "Accept License Agreement".
4. Choose the JDK for your operating platform, i.e., MacOS. Download the DMG
installer (e.g, jdk-11.0.{x}_osx-x64_bin.dmg - about 166MB).
Step 3: Install JDK/JRE
1. Double-click the downloaded Disk Image (DMG) file. Follow the screen instructions
to install JDK/JRE.
2. Eject the DMG file.
3. To verify your installation, open a "Terminal" and issue these commands.

4. // Display the JDK version

5. javac -version
6. javac 11.0.{x}
7.
8. // Display the JRE version
9. java -version
10. java version "11.0.{x}"
11. ......
12.
13. // Display the location of Java Compiler
14. which javac
15. /usr/bin/javac
16.
17. // Display the location of Java Runtime
18. which java

/usr/bin/java

Step 3: Write a Hello-World Java Program

1. Create a directory called "myProject" under your home directory (Launch "Finder"
⇒ "Go" ⇒ "Home"; Select "File" ⇒ "New Folder" ⇒ "myProject").
In Mac OS X, the home directory of the current user can be referenced as " ~".
Hence, this new directory can be referenced as "~/myProject".
2. Use a programming text editor (such as Sublime Text or Atom) to input the
following source code and save as "Hello.java" under the directory
"~/myProject".
(If you use Mac OS X's default text editor "TextEdit" (NOT recommended), you
need to open a new file ⇒ choose "Format" ⇒ "Make Plain Text" ⇒ Enter the
source code ⇒ Save as "Hello.java".)
3. /*
4. * My First Java program to say Hello
5. */
6. public class Hello { // Save as "Hello.java" under "~/myProject"
 7. public static void main(String[] args) {
8. System.out.println("Hello, world from Mac!");
9. }

Step 4: Compile and Run the Hello -World Java Program

1. To compile the source code "Hello.java", open a new "Terminal" ("Go" ⇒

"Utilities" ⇒ "Terminal") and issue these commands (as illustrated):
2. // Change Directory (cd) to where "Hello.java" resides
3. cd ~/myProject
4.
5. // Check if "Hello.java" exists using list (ls) command
6. ls
7. Hello.java ......
8.
9. // Compile "Hello.java" using JDK compiler "javac"
10. javac Hello.java
11. // If error message appears, correct your source code and re-compile
12.
13. // Check for the compiled output "Hello.class"
14. ls

Hello.class Hello.java ......

15. To run the Hello-world, invoke the Java Runtime "java" as follows:
16. java Hello

Hello, world from Mac!

3. How to Install JDK on Ubuntu

There are several JDK implementations available for Linux, such as Oracle JDK, OpenJDK,
Sun JDK, IBM JDK and GNU Java Compiler. We shall choose the Oracle JDK 8. Ubuntu
chooses OpenJDK as its default JDK, which is not 100% compatible with Oracle JDK.
Step 0: Check if JDK has already been Installed
Open a Terminal and issue this command:

$ javac -version
If a JDK version number (e.g., "javac x.x.x") appears, JDK has already been installed.
You can skip the installation and goto step 2.

To remove OpenJDK, issue command:

$ sudo apt-get purge openjdk-\*

Step 1: Download and Install JDK

1. Goto JDK (Java SE) download site
@ http://www.oracle.com/technetwork/java/javase/downloads/index.html. Under
"Java Platform, Standard Edition" ⇒ "Java SE 11.0.{x}" ⇒ Click JDK's "Download" ⇒
Under "Java SE Development Kit 11.0.{x}" ⇒ Check "Accept License Agreement" ⇒
Select "Linux", "tar.gz" package, (e.g., "jdk-11.0.{x}-linux-x64_bin.tar.gz" -
171MB).
The tarball will be downloaded in directory "~/Downloads", by default.
2. We shall install JDK under "/usr/local/java" (or Ubuntu's default JDK
directory /usr/lib/jvm; or /opt/java). First, create a directory "java" under
"/usr/local". Open a Terminal and issue these commands:
3. $ cd /usr/local

$ sudo mkdir java

Extract the downloaded package (Check your downloaded filename!)
$ cd /usr/local/java
$ sudo tar xzvf ~/Downloads/jdk-11.0.{x}-linux-x64_bin.tar.gz
// x: extract, z: for unzipping gz, v: verbose, f: filename
JDK shall be extracted in a folder "/usr/local/java/jdk-11.0.{x}", where {x} is
the update number.
4. Inform the Ubuntu to use this JDK/JRE:

5. // Setup the location of java, javac and javaws

6. $ sudo update-alternatives --install "/usr/bin/java" "java"
"/usr/local/java/jdk-11.0.{x}/bin/java" 1
7. // --install symlink name path priority
8. $ sudo update-alternatives --install "/usr/bin/javac" "javac"
"/usr/local/java/jdk-11.0.{x}/bin/javac" 1
9. $ sudo update-alternatives --install "/usr/bin/javaws" "javaws"
"/usr/local/java/jdk-11.0.{x}/bin/javaws" 1
10.
11. // Use this Oracle JDK/JRE as the default
12. $ sudo update-alternatives --set java /usr/local/java/jdk-
11.0.{x}/bin/java
13. // --set name path
14. $ sudo update-alternatives --set javac /usr/local/java/jdk-
11.0.{x}/bin/javac

$ sudo update-alternatives --set javaws /usr/local/java/jdk-

11.0.{x}/bin/javaws
The above steps set up symlinks java, javac, javaws at /usr/bin (which is in the
PATH), that link to /etc/alternatives and then to JDK bin directory.
The "alternatives" system aims to resolve the situation where several programs
fulfilling the same function (e.g., different version of JDKs). It sets up symlinks
thru /etc/alternatives to refer to the actual programs to be used.
$ ls -ld /usr/bin/java*
 lrwxrwxrwx 1 root root xx xxx xx xx:xx /usr/bin/java ->
/etc/alternatives/java
lrwxrwxrwx 1 root root xx xxx xx xx:xx /usr/bin/javac ->
/etc/alternatives/javac
lrwxrwxrwx 1 root root xx xxx xx xx:xx /usr/bin/javaws ->
/etc/alternatives/javaws

$ ls -ld /etc/alternatives/java*
lrwxrwxrwx 1 root root xx xxx xx xx:xx /etc/alternatives/java ->
/usr/local/java/jdk-11.0.{x}/bin/java
lrwxrwxrwx 1 root root xx xxx xx xx:xx /etc/alternatives/javac ->
/usr/local/java/jdk-11.0.{x}/bin/javac
lrwxrwxrwx 1 root root xx xxx xx xx:xx /etc/alternatives/javaws ->
/usr/local/java/jdk-11.0.{x}/bin/javaws
Alternatively, you can include the JDK's bin and JRE's bin into the PATH directly.
15. To verify the JDK installation, issue these commands:

16. // Show the Java Compiler (javac) version

17. $ javac -version
18. javac 11.0.{x}
19.
20. // Show the Java Runtime (java) version
21. $ java -version
22. java version "11.0.{x}"
23. ......
24.
25. // Show the location of javac and java
26. $ which javac
27. /usr/bin/javac
28.
29. $ which java

/usr/bin/java
30. [Don't Do this step - It is taken care by "alternative" in Step 3. Keep here to show
you how to set PATH.]
Add JDK's binary directory ("bin") to the "PATH" by editing "/etc/profile":
31. $ cd /etc

$ gksudo gedit profile // OR "sudo nano profile" to use the console-

based nano editor
Add these lines at the end of the file "/etc/profile", replace "{x}" with the actual
number:

export JAVA_HOME=/usr/local/java/jdk-11.0.{x}
export PATH=$JAVA_HOME/bin:$PATH

Rerun the configuration file by:

// Refresh
$ source /etc/profile
 // Check the new settings for JAVA_HOME and PATH
$ echo $JAVA_HOME
/usr/local/java/jdk-11.0.{x}

$ echo $PATH
.....:/usr/local/java/jdk-11.0.{x}/bin

Step 2: Compile and Run a Hello -world Java Program

1. File Explorer ⇒ Home ⇒ Create a new folder called "myProject" to keep our works.
2. Open "Text Editor" (gedit). Enter the following source code and save as
"Hello.java" under the "~/myProject" directory created earlier.
3. public class Hello { // To save as "Hello.java" under "~/myProject"
4. public static void main(String[] args) {
5. System.out.println("Hello, world from Ubuntu!");
6. }

7. To compile the Hello-world Java program, launch a Terminal and issue these
commands:

8. // Change directory to where the source code resides

9. $ cd ~/myProject
10.
11. // List the contents of current directory. Check for "Hello.java"
12. $ ls
13. ...... Hello.java ......
14.
15. // Compile "Hello.java" into "Hello.class"
16. $ javac Hello.java
17.
18. // Check for "Hello.class"
19. $ ls

...... Hello.class ......

20. Run the Hello-world Java program:

21. // Run "Hello.class"

22. $ java Hello

Hello, world from Ubuntu!

4. Common Errors in installing JDK

SYMPTOM: Cannot compile Java program from the CMD shell (e.g., "javac
Hello.java" does not work!)
ERROR MESSAGE: 'javac' is not recognized as an internal or external
command, operable program or batch file.
PROBABLE CAUSES: The PATH environment variable, which maintains a list of
search paths for executable
programs (including "javac.exe"), does not include JDK's bin directory.
POSSIBLE SOLUTIONS:
1) Start a CMD shell (click "Start" button ⇒ "run..." ⇒ enter "cmd")
and issue a path command:
prompt> path
PATH=.......
2) Check if it includes your JDK's "bin" directory. For example, suppose
that your JDK is installed
in "c:\program files\java\jdk-11.0.1", then PATH should include
"c:\program files\java\jdk-11.0.1\bin".

Otherwise, include JDK's bin directory in the PATH environment

variable.
Read "Step 3 of How to install JDK".

SYMPTOM: Can compile but cannot run Java program from the CMD shell (e.g.,
"java Hello" does not work!)
ERROR MESSAGE (Post JDK 1.7): Error: Could not find or load main class Xxx
ERROR MESSAGE (Pre JDK 1.7): Exception in thread "main"
java.lang.NoClassDefFoundError: Xxx
PROBABLE CAUSES:
 1) The Java class (in this example, Hello.class) is NOT in the current
directory.
2) The CLASSPATH environment variable is set, but does not include the
current directory ".".
POSSIBLE SOLUTIONS:
1) Issue a "dir" command to list the contents of the current directory.
Check that it contains the Java class to be run (e.g., Hello.class).
You need to compile the source program (".java") to get the class
file (".class").
2) If the Java class is present in the current directory, issue a "set
classpath" command
to check its settings:
prompt> set classpath
CLASSPATH=.......
If you receive the message "Environment variable CLASSPATH not
defined" and
your program is correct, I can't help you here.
Otherwise, if the CLASSPATH is defined, for beginner, I suggest that
you remove
the CLASSPATH environment variable.
From "Control Panel"
⇒ System
⇒ (Vista only) Advanced system settings
⇒ Switch to "Advanced" tab
⇒ Environment Variables
⇒ System variables (and also User variables)
⇒ Select variable "CLASSPATH"
⇒ Delete (Delete from both the System variables and User
variables)
3) (For Advanced Users Only) If CLASSPATH is not set, it is defaulted to
the current directory.
However, if CLASSPATH is set, the current directory is NOT
implicitly included.
You can include the current directory (denoted by a single dot ".")
in front of the
existing class-paths.
Read "Java Applications and Environment Variable" for more discussion
on CLASSPATH.

SYMPTOM: Can compile but cannot run the Hello-world program (e.g., "java
Hello" does not work!)
ERROR MESSAGE (Post JDK 1.7): Error: Main method not found in class Hello.
POSSIBLE SOLUTIONS: Check whether there is a main() method in your program,
and the signature of your main()
 as shown in the error message.

5. JDK 11 Launch Single-Source-File New

Feature
In JDK 11, you can compile/run a single-file program in one step, without explicit
compliation.
1. Write a "Hello.java" (see previous section).
2. Delete "Hello.class", if it exists.
3. You can compile/run "Hello.java" in one command as follows:
4. // Change directory to the directory containing Hello.java
5.
6. // Compile and Run

java Hello.java

Notes:
 This is applicable to single source-file only.
 No need to use javac to compile the program.
 It compiles in memory (without producing a .class file), and run.
 This feature is introduced for beginners to learn Java, and for professionals to test a
Java feature.
 The filename and classname need not be the same.

6. First Java Program with Eclipse IDE

1. You need to first install Eclipse. Read "How to Install Eclipse".
2. You can then proceed to write your first Java program. Read "Writing your first
Java Program with Eclipse".
3. Eclipse allow you to debug program graphically. Read "Debugging program in
Eclipse".
7. First Java Program with NetBeans IDE
1. You need to first install NetBeans. Read "How to Install NetBeans".
2. You can then proceed to write your first Java program. Read "Writing your first
Java program with NetBeans".
3. NetBeans allow you to debug program graphically. Read "Debugging program in
NetBeans".
8. (Advanced) External JAR Files and Native
Libraries
Notes: This section is applicable to JDK prior to JDK 9. JDK 9 introduces a new level called
"module" on top of package, and "jmod" files for Java modules. Need to revise this
section for JDK 9.
External Java packages (such as Servlet, MySQL Connector/J, JOGL, JUnit) are often
distributed in JAR files (Java Archive - a single-file package of many Java classes), with
possibly Native Libraries (".lib" and ".dll" in Windows, or ".a" and ".so" in Linux/Mac).
External JAR Files (".jar")
If external JAR files are not properly included:
 During the compilation, you will receive compilation error "cannot find symbol" on
classes belonging to the external packages.
 During execution, you will get a runtime error "Could not find or load main class xxx"
or "NoClassDefFoundError".
To include external JAR files, you can either:
1. Copy all the JAR files of the external packages to the Java's Extension
Directories (NOT applicable to JDK 9).
o For Windows, the JDK extension directory is located at
"<JAVA_HOME>\jre\lib\ext" (e.g., "c:\Program
Files\Java\jdk1.8.0_xx\jre\lib\ext").
o For Mac, the JDK extension directories are " /Library/Java/Extensions" and
"/System/Library/Java/Extensions ".
o For Ubuntu, the JDK extension directories are "<JAVA_HOME>/jre/lib/ext"
(e.g., "/usr/user/java/jdk1.8.0_xx/jre/lib/ext") and
"/usr/java/packages/lib/ext".
The location of JDK's extension directories is kept in Java's System Property
"java.ext.dirs". You can print its contents
via System.out.println(System.getProperty("java.ext.dirs")) .
2. You can also include all the JAR files in the CLASSPATH environment
variable. CLASSPATH may contain directories (of Java classes) or JAR files (single-file
archive of Java classes). If you set the CLASSPATH, you must also include the current
directory (denoted as ".").
o For Windows, set the CLASSPATH in Control Panel ⇒ System ⇒ Advanced
system settings ⇒ Advanced ⇒ Environment Variables ⇒ System Variables ⇒
New ⇒ In "Variable name", enter "CLASSPATH" ⇒ In "Variable value", enter
".;path1\xxx.jar;path2\yyy.jar", where the entries are separated by a
semi-colon (;).
o For Linux and Mac OS:
Edit ~/.profile or ~/.bash_profile (or /etc/profile for system-wide
setting) to include the following line at the end of the file:
export CLASSPATH=.:path1/xxx.jar:path2/yyy.jar
The entries are separated by colon (:).
3. You can also set the CLASSPATH in the javac/java command-line via the option -
cp <paths> (or -classpath <paths>), for example,
4. // For Windows
5. // Compile Java source code
6. javac -cp .;path1\xxx.jar;path2\yyy.jar ClassName.java
7. // Run Java class
8. java -cp .;path1\xxx.jar;path2\yyy.jar ClassName
9.
10. // For Mac OS X and Ubuntu
11. // Compile Java source code
12. javac -cp .:path1/xxx.jar:path2/yyy.jar ClassName.java
13. // Run Java class

java -cp .:path1/xxx.jar:path2/yyy.jar ClassName

External Native Libraries (".lib", ".dll", ".a", ".so")

Some external package may provide static or shared native libraries in the form of " .lib"
(Windows' static LIBrary), ".dll" (Windows' Dynamically Link Library), ".a" (Unix's static
(Archive) library), or ".so" (Unix's Shared Object library).
Native Libraries are to be kept in a directory accessible via JRE's Property
"java.library.path", which normally but not necessarily includes all the directories in
the PATH environment variable.
Native libraries are not involved in the compilation. But if they are not properly included
during runtime time, you will get a runtime error "java.lang.UnsatisfiedLinkError:
no xxx in java.library.path".

To include external native libraries:

1. Copy the native libraries into a system library directory,
e.g., c:\windows\system32 (Windows), /usr/lib or /usr/local/lib (Mac OS X /
Unix). You can verify that the directory is included in Java's System Property
"java.library.path",
via System.out.println(System.getProperty("java.library.path")) .
2. You can also set the native library path via the java's command-line option -
Djava.library.path=xxx, for example,
3. // Run a Java program

java -Djava.library.path=xxx ClassName

Eclipse/NetBeans
Using an IDE can greatly simplifies inclusion of external packages. Read "Eclipse How-To"
or "NetBeans How-To".
Link to References & Resources
Latest version tested: JDK 11.0.1
Last modified: March, 2019
Feedback, comments, corrections, and errata can be sent to Chua Hock-Chuan
([email protected]) | HOME