Java 6 Standard Edition Free Download Mac Updated

Roberson Mely1966 – April 22, 2022

Java 6 Standard Edition Free Download Mac

How to Install JDK 17 (on Windows, macOS & Ubuntu) and Become Started with Coffee Programming

The Java Development Kit (JDK), officially named "Java Platform Standard Edition" or "Java SE", is needed for writing and running Java programs.

JDK Variants

There are few variants of JDK:

OpenJDK: Currently, the "OpenJDK" developed past Oracle and the Java customs (@ https://openjdk.java.net/) provides a gratis and open-source JDK official reference implementation.
OracleJDK: This article is based on the "OracleJDK" (@ https://www.oracle.com/java/) (due to legacy), which is complimentary for personal and development apply but no longer gratis for commercial use.

JDK Versions

Reference: "Java Version History" @ https://en.wikipedia.org/wiki/Java_version_history.

JDK Blastoff and Beta (1995): Lord's day Microsystem appear Java in September 23, 1995.
JDK 1.0 (January 1996): Originally called Oak (named after the oak tree outside James Gosling'due south office). Renamed to Java i in JDK one.0.2.
JDK 1.1 (February 1997): Introduced AWT effect model, inner course, JavaBean, JDBC, and RMI.
J2SE 1.2 (JDK 1.2) (Dec 1998): Re-branded as "Java ii" and renamed JDK to J2SE (Java ii Standard Edition). Also released J2EE (Coffee two Enterprise Edition) and J2ME (Java two Micro Edition). Included JFC (Coffee Foundation Classes - Swing, Accessibility API, Java 2D, Pluggable Look & Feel, and Elevate & Drop). Also introduced Collection Framework and JIT compiler.
J2SE 1.3 (JDK 1.3) (May 2000): Introduced Hotspot JVM.
J2SE ane.four (JDK one.4) (February 2002): Introduced assert statement, not-blocking IO (nio), logging API, image IO, Java webstart, regular expression (regex) support.
J2SE 5.0 (JDK 5) (September 2004): Officially called 5.0 instead of 1.five (past dropping the 1.). Introduced generics, autoboxing/unboxing, annotation, enum, varargs, for-each loop, static import. Meet "JDK five New Features".
Coffee SE vi (JDK half-dozen) (December 2006): Renamed J2SE to Java SE (Java Platform Standard Edition). No new language features. See "JDK 6 New Features".
Java SE seven (JDK 7) (July 2011): Showtime version after Oracle purchased Sun Microsystem - aslo called OracleJDK. Introduced Strings in switch statement, Binary integer literals, allowing underscores in numeric literals, improved type inference for generic instance creation (or diamond operator <>), Catching multiple exception types and rethrowing exceptions with improved blazon checking. Encounter "JDK 7 New Features".
Java SE 8 LTS (JDK viii) (March 2014): Included back up for Lambda expressions, default and static methods in interfaces, improved collection, and JavaScript runtime. Also integrated JavaFX graphics subsystem. Encounter "JDK 8 New Features".
Java SE 9 (JDK 9) (September 21, 2017): Introduced modularization of the JDK (module) under project Jigsaw, the Java Vanquish (jshell), and more. Run into "JDK 9 New Features".
Java SE 10 (18.3) (JDK 10) (March 2018): Introduced var for blazon inference local variable (similar to JavaScript). Introduced time-based release versioning with two releases each year, in March and September, denoted as YY.M. Removed native-header generation tool javah. Come across "JDK 10 New Features".
Java SE 11 LTS (18.nine) (JDK eleven) (September 2018): Extended var to lambda expression. Standardize HTTP client in java.cyberspace.http. Support TLS one.3. Make clean upward the JDK and the installation package (removed JavaFX, JavaEE, CORBA modules, deprecated Nashorn JavaScript engine). OracleJDK is no longer gratuitous for commercial apply, simply OpenJDK is still free. Run into "JDK 11 New Features".
Java SE 12 (19.3) (JDK 12) (March 2019): Switch Expression (preview). See "JDK 12 New Features".
Java SE thirteen (19.nine) (JDK 13) (September 2019): Switch Expression (preview), Multi-line Text Block (preview). See "JDK 13 New Features".
Coffee SE fourteen (20.iii) (JDK 14) (March 2020): Records (preview)
Java SE 15 LTS (20.9) (JDK 15) (September 2020):
Java SE 16 (JDK xvi) (March 2021):
Java SE 17 LTS (JDK 17) (September 2021):
Coffee SE 18 (JDK 18) (March 2022):

"JDK" or "JRE"?

JRE (Java Runtime), which include a Java Virtual Machine and core libraries, is needed for running Java programs. JDK (Java Evolution Kit), which includes JRE plus the evolution tools (such equally compiler and debugger), is demand for writing as well as running Coffee programs. In other words, JRE is a subset of JDK. Since you are supposed to write Coffee Programs instead of merely running Java programs, yous should install JDK, which includes JRE.

How To Install JDK on Windows

Stride 0: Un-Install Older Version(s) of JDK/JRE

I recommend that yous install merely the latest JDK. Although yous tin install multiple versions of JDK/JRE concurrently, information technology is messy.

If you take previously installed older version(due south) of JDK/JRE, un-install ALL of them. Goto "Command Console" ⇒ (optional) "Programs" ⇒ "Programs and Features" ⇒ United nations-install ALL programs begin with "Coffee", such as "Java SE Evolution Kit ...", "Coffee SE Runtime ...", "Java X Update ...", and etc.

Step ane: Download JDK

Goto JDK (or Java SE) download site @ https://www.oracle.com/coffee/technologies/javase-downloads.html.
Under "Java SE Development Kit 17.0.{x} downloads".
Select "Windows" ⇒ Download the "x64 Installer" (e.k., "jdk-17_windows-x64_bin.exe" - about 152MB).

Step 2: Install JDK

Run the downloaded installer. Have the defaults and follow the screen instructions to complete the installation. Past default, JDK is installed in directory "C:\Program Files\Java\jdk-17.0.{x} ", where {x} denotes the running "update number" starting from 1.

Launch "File Explorer". Navigate to "C:\Program Files\Java" to inspect this directories. Take note of your JDK Installed Directory jdk-17.0.{x} , in particular, the update number {x} .

I shall refer to the JDK Installed Directory as <JAVA_HOME> , hereafter, in this article (corresponding to environment variable %JAVA_HOME% in Windows or $JAVA_HOME in Unix/macOS).

Step three: (SKIP for JDK 17, 16, 16 - kept for completeness) Include JDK's "bin" Directory in the PATH

Windows' Control Prompt (CMD) searches the current directory and the directories listed in the PATH environment variable for executable programs.

JDK'south programs (such as Coffee compiler "javac.exe" and Java runtime "java.exe") reside in the sub-directory "bin" of the JDK installed directory. JDK's "bin" needs to exist added into the PATH.

Prior to JDK fifteen, you demand to explicitly add JDK's "bin" into the PATH. Starting from JDK xv, the installation process adds the directory "C:\Program Files\Common Files\Oracle\Coffee\javapath" to the PATH. The "javapath" directory is a link to "javapath_target_xxxxxx", which contains a copy of the following JDK programs:

java.exe: Java Runtime
javac.exe: Java Compiler
javaw.exe: Coffee Runtime for Windows Console-less
jshell.exe: Java Control-line Shell (since JDK ten) - a Read-Evaluate-Impress Loop (REPL) which evaluates declarations, statements, and expressions as they are entered and immediately shows the results.

Link is used so that you can continue multiple copies (versions) of JDK.

To edit the PATH surround variable in Windows 10:

Launch "Control Panel" ⇒ (Optional) "Arrangement and Security" ⇒ "Arrangement" ⇒ Click "Advanced organisation settings" on the left pane.
Switch to "Advanced" tab ⇒ Click "Environment Variables" button.
Nether "System Variables" (the bottom pane), scroll down to select variable "Path" ⇒ Click "Edit...".
For Newer Windows 10:
You shall see a Tabular array listing all the existing PATH entries (if not, goto next step). Click "New" ⇒ Click "Browse" and navigate to your JDK'southward "bin" directory, i.east., "c:\Program Files\Coffee\jdk-15.0.{10}\bin ", where {x} is your installation update number ⇒ Select "Move Up" to move this entry all the fashion to the Superlative.
For Older Windows x (Fourth dimension to change your computer!):
(CAUTION: Read this paragraph three times before doing this step! Don't push "Utilise" or "OK" until you are 101% sure. In that location is no Disengage!!!)
(To exist Prophylactic, copy the content of the "Variable value" to Notepad before irresolute information technology!!!)
In "Variable value" field, Append "c:\Program Files\Coffee\jdk-15.0.{10}\bin" (where {x} is your installation update number) IN FRONT of all the existing directories, followed past a semi-colon (;) to split the JDK's bin directory from the balance of the existing directories. DO NOT DELETE whatever existing entries; otherwise, some existing applications may not run.
```
Variable name  :                              PATH                            Variable value :                              c:\Plan Files\Java\jdk-15.0.{x}\bin;                            [exercise not delete exiting entries...]            
```

You need to re-started CMD for the new environment settings to take effect.

Step 4: Verify the JDK Installation

Launch a CMD via one of the following means:

Click "Search" push ⇒ Blazon "cmd" ⇒ Cull "Command Prompt", or
Right-click "Beginning" button ⇒ run... ⇒ enter "cmd", or
Click "Beginning" push ⇒ Windows System ⇒ Command Prompt

Issue the following commands to verify your JDK installation:

(Skip for JDK 17, xvi, xv) Issue "path" command to list the contents of the PATH environs variable. Check to make sure that your JDK'southward "bin" is listed in the PATH.
```
              path              PATH=c:\Program Files\Java\jdk-{twenty.y.z}\bin;other entries...            
```

Outcome the post-obit commands to verify that JDK/JRE are properly installed and display their version:

                javac -version              javac                17.0.i                                          java -version              java version "17.0.1" 2021-x-19 LTS Java(TM) SE Runtime Environment (build 17.0.1+12-LTS-39) Java HotSpot(TM) 64-Bit Server VM (build 17.0.1+12-LTS-39, mixed fashion, sharing)

Footstep 5: Write a Hello-World Coffee Program

Create a directory to keep your works, east.grand., "d:\myProject" or "c:\myProject". Exercise Non salvage your works in "Desktop" or "Documents" as they are hard to locate. The directory name shall not comprise blank or special characters. Use meaningful but curt name as it is easier to blazon.
Launch a programming text editor (such every bit TextPad, NotePad++, Sublime Text, Cantlet). Begin with a new file and enter the following source code. Save the file as "Hi.java", under your piece of work directory (e.m., d:\myProject).
```
                public class Hello {      public static void main(Cord[] args) {       Arrangement.out.println("Hullo, world!");    } }
```

Pace 6: Compile and Run the Howdy-World Coffee Plan

To compile the source code "Hello.coffee":

Get-go a CMD Vanquish (Search ⇒ enter "cmd" ⇒ select "Command Prompt").
Ready the Current Drive to the drive where yous saved your source file "Howdy.java".
If you use drive "c", skip this step.
Else if you use bulldoze "d", enter " d: " equally follow:
```
              d:              D:\xxx>            
```
Set the Current Working Directory to the directory that y'all saved your source file via the cd (Alter Directory) control. For example, suppose that your source file is saved in directory "myProject".
```
              cd \myProject              D:\myProject>            
```

Issue a dir (List Directory) command to confirm that your source file is present in the electric current directory.

              dir              ...... 20-xxx-xx  twenty:xx PM               277                Hello.java                ......

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 "Mutual JDK Installation Errors", if you encounter problem compiling your program.

The output of the compilation is a Java class called "Hello.class". Issue a dir (Listing Directory) control once more to check for the output.

              dir              ...... 20-xxx-xx  xx:xx PM               416                Hello.class                xx-30-twenty  xx:20 PM               277 Hello.java ......

To run the programme, invoke the Java Runtime " java ":

          java Hello          Hello, world!

Everything that can possibly get incorrect will go wrong: Read "JDK Installation Mutual Errors".

Step 7: (For Avant-garde Users Only) JDK's Source Code

Source code for JDK is provided and kept in "<JAVA_HOME>\lib\src.goose egg" (or "<JAVA_HOME>\src.zip" prior to JDK nine). I strongly recommend that y'all to go through some of the source files such as "Cord.coffee", "Math.coffee", and "Integer.coffee", under "java\lang", to learn how experts program.

How to Install JDK on macOS

Step one: Check if JDK has been Pre-Installed

To check if JDK has been installed, open a "Terminal" (Search "Last"; or Finder ⇒ Become ⇒ Utilities ⇒ Terminal) and issue this control:

          javac -version

If a JDK version number is returned (east.g., JDK ten.ten.x), then JDK has already been installed. If the JDK version is prior to 11, proceed to Footstep 2 to install the latest JDK; otherwise, proceed to "Step 3: Write a Hello-world Java program".
If message "control non found" appears, JDK is NOT installed. Go on to the "Step ii: Install JDK".
If message "To open up javac, you need a Java runtime" appears, select "Install" and follow the instructions to install JDK. And then, proceed to "Pace three: Write a Hello-globe Java program".

Footstep 2: Download JDK

Goto JDK (or Java SE) download site @ https://www.oracle.com/java/technologies/javase-downloads.html.
Under "Coffee SE Evolution Kit 17.0.{x} downloads".
Select "macOS" ⇒ Download the "x64 Installer" (e.g., "jdk-17_windows-x64_bin.exe" - about 152MB).
Under "Oracle JDK", click "JDK Download".
Download the "x64 DMG installer" (e.yard, jdk-17_macos-x64_bin. dmg - about 168MB (I am assuming that you are using Intel processor, not ARM processor. Mac is moving to ARM processor.)

Step 3: Install JDK/JRE

Double-click the downloaded Disk Paradigm (DMG) file. Follow the screen instructions to install JDK/JRE.
Eject the DMG file.

To verify your installation, open up a "Terminal" and consequence these commands.

                javac -version              javac 17.0.{ten}                            coffee -version              java version "17.0.{ten}" ......                            which javac              /usr/bin/javac                            which coffee              /usr/bin/java

Pace 3: Write a Hello-World Java Plan

Create a directory called "myProject" under your "dwelling" directory (Launch "Finder" ⇒ "Go" ⇒ "Dwelling"; Select "File" ⇒ "New Binder" ⇒ "myProject").
In macOS/Unix, the "dwelling" directory of the current user tin be referenced equally "~". Hence, this new directory can exist referenced equally "~/myProject".
Employ a programming text editor (such as Sublime Text or Atom) to input the post-obit source lawmaking and salvage equally "Hi.java" under the directory "~/myProject".
(If y'all utilize macOS's default text editor "TextEdit" (NOT recommended), you lot demand to open a new file ⇒ choose "Format" ⇒ "Make Plain Text" ⇒ Enter the source code ⇒ Save as "How-do-you-do.java".)
```
                public form Hello {       public static void main(String[] args) {       Organization.out.println("Hello, world from Mac!");    } }
```

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

To compile the source lawmaking "Hi.java", open up a new "Last" ("Go" ⇒ "Utilities" ⇒ "Terminal") and issue these commands (as illustrated):

                cd ~/myProject                            ls              Hello.java   ......                            javac Hello.java                               ls              Hullo.course   Hello.coffee   ......

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

              java Howdy              Hullo, world from Mac!

How to Install JDK (xv) on Ubuntu

Nosotros shall try both the OpenJDK (free and open-source) and the Oracle JDK (free for personal and development, but not gratuitous for product).

Stride 0: Check if JDK has already been Installed

Open a Terminal and effect this command:

$          javac -version

If a JDK version number (e.g., "javac x.10.x") appears, JDK has already been installed. You can skia the installation and goto Open2.

Step 1a: Install OpenJDK

[TODO]

To remove OpenJDK, event command:

$          sudo apt-get purge openjdk-\*

Step 1b: Install Oracle JDK

Goto Oracle JDK (Java SE) download site @ https://www.oracle.com/coffee/technologies/javase-downloads.html ⇒ Under "Oracle JDK", click "JDK Download" ⇒ Select "Linux x64 Compressed Annal" parcel (e.g., "jdk-fifteen.0.{x}-linux-x64_bin.tar.gz" - 179MB). The tarball will exist downloaded in directory "~/Downloads", by default.
We shall install JDK under "/usr/local/java" (or Ubuntu's default JDK directory /usr/lib/jvm; or /opt/coffee). First, create a directory "java" under "/usr/local". Open a Terminal and issue these commands:
```
$              cd /usr/local              $              sudo mkdir java            
```
Extract the downloaded package (Check your downloaded filename!)
```
$              cd /usr/local/java              $              sudo tar xzvf ~/Downloads/jdk-15.0.{x}-linux-x64_bin.tar.gz            
```
JDK shall exist extracted in a folder "/usr/local/java/jdk-15.0.{10}", where {10} is the update number.

Inform the Ubuntu to utilize this JDK/JRE:

                $              sudo update-alternatives --install "/usr/bin/coffee" "java" "/usr/local/java/jdk-15.0.{x}/bin/java" i               $              sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/local/java/jdk-fifteen.0.{x}/bin/javac" one              $              sudo update-alternatives --install "/usr/bin/jshell" "java/usr/local/coffee/jdk-15.0.{ten}/bin/jshell" 1               $              sudo update-alternatives --set java /usr/local/java/jdk-15.0.{10}/bin/java               $              sudo update-alternatives --set javac /usr/local/java/jdk-15.0.{x}/bin/javac              $              sudo update-alternatives --set jshell /usr/local/java/jdk-fifteen.0.{10}/bin/jshell

The above steps fix up symlinks java, javac, jshell at /usr/bin (which is in the PATH), that link to /etc/alternatives and and so to JDK bin directory.
The "alternatives" system aims to resolve the state of affairs where several programs fulfilling the aforementioned part (e.g., different version of JDKs). It sets up symlinks thru /etc/alternatives to refer to the actual programs to exist used.

$              ls -ld /usr/bin/java*              lrwxrwxrwx 1 root root xx xxx xx twenty:xx /usr/bin/java -> /etc/alternatives/java ......              $              ls -ld /etc/alternatives/java*              lrwxrwxrwx 1 root root xx xxx xx xx:xx /etc/alternatives/java -> /usr/local/coffee/jdk-15.0.{ten}/bin/java ......               java -> /usr/bin/java (thru PATH) -> /etc/alternatives/java -> /usr/local/java/jdk-15.0.{x}/bin/java (actual program)

Alternatively, you tin include the JDK's bin into the PATH direct.

To verify the JDK installation, effect these commands:

                $              javac -version              javac xv.0.{x}               $              java -version              coffee version "15.0.{10}" ......               $              which javac              /usr/bin/javac              $              which java              /usr/bin/java

(Don't Do this step - It is taken care by "alternatives" in Pace 3. Keep here to show you lot how to gear up PATH.)
Add together JDK's binary directory ("bin") to the "PATH" by editing "/etc/profile":

$              cd /etc              $              sudo nano profile

Add these lines at the stop of the file "/etc/profile", supersede "{x}" with the bodily number:

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

Rerun the configuration file by:

                $              source /etc/profile               $              echo $JAVA_HOME              /usr/local/java/jdk-15.0.{x}              $              echo $PATH              /usr/local/coffee/jdk-15.0.{x}/bin:......

Step two: Compile and Run a Hello-globe Java Plan

File Explorer ⇒ Dwelling house ⇒ Create a new binder called "myProject" to keep our works.
Open "Text Editor" (gedit). Enter the following source lawmaking and salve as "Hello.coffee" under the "~/myProject" directory created earlier.
```
public class How-do-you-do {       public static void master(String[] args) {       System.out.println("Hello, world from Ubuntu!");    } }
```

To compile the Hello-globe Coffee plan, launch a Terminal and issue these commands:

                $              cd ~/myProject               $              ls              ...... Hello.java ......               $              javac Hello.coffee               $              ls              ...... Hullo.course ......

Run the How-do-you-do-world Java program:

                $              java Hi              Hello, world from Ubuntu!

Notes: Starting from JDK eleven, you can compile and run the hello-world in one single footstep via:

            $          java How-do-you-do.java          Hello, globe from Ubuntu!

Source-Code Editors & IDEs for Java Programming

Eclipse IDE

You lot demand to first install Eclipse. Read "How to Install Eclipse".
javaan then go on to write your outset Coffee program. Read "Writing your beginning Coffee Program with Eclipse".
Eclipse allow y'all to debug program graphically. Read "Debugging program in Eclipse".

NetBeans IDE

You need to beginning install NetBeans. Read "How to Install NetBeans".
You tin and then proceed to write your first Java programme. Read "Writing your kickoff Java program with NetBeans".
NetBeans allow you to debug program graphically. Read "Debugging program in NetBeans".

Visual Studio (VS) Lawmaking IDE

Click Hither, look for "VS Lawmaking for Java Programming"

Sublime Text (for Windows, macOS, Linux)

Click HERE, look for "Sublime Text for Java Programming"

Atom (for Windows, macOS, Linux)

[TODO]

TextPad (for Windows only)

Click HERE, expect for "TextPad for Java Programming".

NotePad++ (for Windows but)

Click HERE, look for "NotePad++ for Coffee Programming".

(JDK xi New Feature) Launch Unmarried-Source-File

From JDK eleven, you can "compile and run" a single-file program in ane step, without explicit compilation.

Write a "Hi.java" (see previous department).
Delete "Hullo.class", if it exists.

You can compile/run "Hello.java" in one command as follows:

                              java How-do-you-do.java              Hi, world!

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 examination a Java feature.
The filename and classname need non exist the same.

How To Set JAVA_HOME Environs Variable

Many Java applications (such as Tomcat) require the surroundings variable JAVA_HOME to be set to the JDK installed directory.

See "How to set JAVA_HOME for Windows" or "How to ready JAVA_HOME for macOS/Linux".

Common Errors in installing JDK

          SYMPTOM:          Cannot compile Java programme from the CMD shell (due east.chiliad., "javac Hello.java" does not work!)          ERROR MESSAGE:          'javac' is not recognized as an internal or external command, operable plan or batch file.          Probable CAUSES:          The PATH environs variable, which maintains a list of search paths for executable    programs (including "javac.exe"), does not include JDK'south bin directory.          POSSIBLE SOLUTIONS:          1) Get-go a CMD beat out (click "Outset" button ⇒ "run..." ⇒ enter "cmd") and issue a          path          command:          prompt>          path          PATH=.......    2) Bank check if information technology includes your JDK'due south "bin" directory. For example, suppose that your JDK is installed        in "c:\program files\java\jdk-15.0.1", then PATH should include "c:\program files\coffee\jdk-xv.0.1\bin".       Otherwise, include JDK'due south bin directory in the PATH environment variable.       Read "Step iii of How to install JDK".

          SYMPTOM:          Can compile but cannot run Java program from the CMD vanquish (due east.thousand., "java Hello" does not piece of work!)          Error MESSAGE (Mail JDK one.7):          Error: Could not find or load main class Xxx          Mistake MESSAGE (Pre JDK 1.7):          Exception in thread "main" java.lang.NoClassDefFoundError: Thirty          Likely CAUSES:          1) The Java class (in this case, Howdy.class) is Not in the current directory.    2) The CLASSPATH environment variable is gear up, but does not include the current directory ".".          POSSIBLE SOLUTIONS:          1) Event a "dir" command to listing the contents of the current directory.        Check that it contains the Java grade to be run (eastward.yard., Hello.class).        You lot demand to compile the source programme (".java") to get the form file (".course").    2) If the Java class is present in the current directory, upshot a "ready classpath" command       to check its settings:             prompt>          set classpath          CLASSPATH=.......       If you lot receive the message "Environs variable CLASSPATH not divers" and          your plan is right, I tin't assistance you hither.       Otherwise, if the CLASSPATH is defined, for beginner, I propose that you remove         the CLASSPATH environs variable.          From "Control Panel"         ⇒ System         ⇒ (Vista merely) Advanced arrangement settings          ⇒ Switch to "Advanced" tab          ⇒ Surround Variables          ⇒ System variables (and besides User variables)          ⇒ Select variable "CLASSPATH"          ⇒ Delete (Delete from both the Organisation variables and User variables)    3)          (For Advanced Users Only)          If CLASSPATH is not gear up, it is defaulted to the current directory.       All the same, if CLASSPATH is prepare, the current  directory is NOT implicitly included.       You tin can include the current  directory (denoted past a single dot ".") in front of the        existing class-paths.        Read "Java Applications and Environs Variable" for more discussion on CLASSPATH.

          SYMPTOM:          Can compile simply cannot run the Hello-globe plan (e.1000., "java Howdy" does not piece of work!)          ERROR MESSAGE (Post JDK 1.7):          Error: Master method not constitute in class Hullo.          POSSIBLE SOLUTIONS:          Check whether there is a main() method in your program, and the signature of your main()   as shown in the fault message.

(Advanced) External JAR Files and Native Libraries

Notes: This section is applicable to JDK prior to JDK nine. JDK 9 introduces a new level called "module" on acme of package, and "jmod" files for Java modules. Need to revise this department for JDK 9.

External Java API packages (such as Servlet API, MySQL Connector/J, JOGL, JUnit) are frequently distributed in JAR files (Java Archive - a single-file package of many Coffee classes like to ZIP or TAR), with possibly Native Libraries (".lib" and ".dll" in Windows, or ".a" and ".so" in Linux/macOS).

External JAR Files (".jar")

If external JAR files are not properly included:

During the compilation, yous will receive compilation fault "cannot observe symbol" for classes belonging to the external packages.
During execution, yous will become a runtime error "Could not find or load main class xxx" or "NoClassDefFoundError".

To include external JAR files, y'all tin either:

(Prior to JDK 9) Copy all the JAR files of the external packages to the Coffee's Extension Directories (Non applicable from JDK 9).
- For Windows, the JDK extension directory is located at "<JAVA_HOME>\jre\lib\ext" (eastward.g., "c:\Program Files\Java\jdk1.viii.0_xx\jre\lib\ext").
- For macOS, the JDK extension directories are "/Library/Coffee/Extensions" and "/System/Library/Java/Extensions".
- For Ubuntu, the JDK extension directories are "<JAVA_HOME>/jre/lib/ext" (e.g., "/usr/user/java/jdk1.viii.0_xx/jre/lib/ext") and "/usr/java/packages/lib/ext".
The location of JDK's extension directories is kept in Java's Organisation Property "coffee.ext.dirs". You can print its contents via System.out.println(System.getProperty("java.ext.dirs")).
You can also include all the JAR files in the CLASSPATH surround variable. CLASSPATH may incorporate directories (of Java classes) or JAR files (single-file annal of Java classes). If you lot set up the CLASSPATH, y'all must also include the electric current directory (denoted as ".").
- For Windows, set the CLASSPATH in Control Panel ⇒ Organisation ⇒ Advanced system settings ⇒ Advanced ⇒ Environs 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 (;).
- For Linux and macOS: Edit ~/.contour or ~/.bash_profile (or /etc/profile for system-wide setting) to include the post-obit line at the end of the file:
```
consign CLASSPATH=.:path1/xxx.jar:path2/yyy.jar
```
  The entries are separated by colon (:).

You can also fix the CLASSPATH in the javac/java command-line via the selection -cp <paths> (or -classpath <paths>), for example,

                 javac              -cp .;path1\xxx.jar;path2\yyy.jar              ClassName.java  coffee              -cp .;path1\xxx.jar;path2\yyy.jar              ClassName               javac              -cp .:path1/xxx.jar:path2/yyy.jar              ClassName.java  java              -cp .:path1/30.jar:path2/yyy.jar              ClassName

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

Some external packet may provide static or shared native libraries in the grade of ".lib" (Windows' static LIBrary), ".dll" (Windows' Dynamically Link Library), ".a" (Unix's static (Archive) library), or ".then" (Unix's Shared Object library).

Native Libraries are to exist kept in a directory accessible via JRE's Belongings "java.library.path", which normally but not necessarily includes all the directories in the PATH surroundings variable.

Native libraries are not involved in the compilation. Only if they are not properly included during runtime time, you will get a runtime error "java.lang.UnsatisfiedLinkError: no thirty in java.library.path".

To include external native libraries:

Copy the native libraries into a organization library directory, e.g., c:\windows\system32 (Windows), /usr/lib or /usr/local/lib (macOS/Unix). You can verify that the directory is included in Coffee's System Property "coffee.library.path", via System.out.println(System.getProperty("java.library.path")).

You can likewise set the native library path via the java's command-line selection -Djava.library.path=xxx , for example,

                coffee              -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 & Resource