Getting started with Java Language
The Java programming language is...
General-purpose: It is designed to be used for writing software in a wide variety of application domains, and lacks specialized features for any specific domain.
Statically-typed: the compiler checks at compile time that variable types are respected. For example, if a method expects an argument of type
String, that argument must in fact be a string when the method is called.
Object-oriented: most things in a Java program are class instances, i.e. bundles of state (fields) and behavior (methods which operate on data and form the object's interface to the outside world).
Portable: It can be compiled on any platform with
javacand the resultant class files can run on any platform that has a JVM.
Java is intended to let application developers "write once, run anywhere" (WORA), meaning that compiled Java code can run on all platforms that support Java without the need for recompilation.
Java code is compiled to bytecode (the
.class files) which in turn get interpreted by the Java Virtual Machine (JVM). In theory, bytecode created by one Java compiler should run the same way on any JVM, even on a different kind of computer. The JVM might (and in real-world programs will) choose to compile into native machine commands the parts of the bytecode that are executed often. This is called "Just-in-time (JIT) compilation".
Java Editions and Versions
There are three "editions" of Java defined by Sun / Oracle:
- Java Standard Edition (SE) is the edition that is designed for general use.
- Java Enterprise Edition (EE) adds a range of facilities for building "enterprise grade" services in Java. Java EE is covered separately.
- Java Micro Edition (ME) is based on a subset of Java SE and is intended for use on small devices with limited resources.
There is a separate topic on Java SE / EE / ME editions.
Each edition has multiple versions. The Java SE versions are listed below.
There is a separate topic on Installing Java (Standard Edition).
Compiling and running Java programs
There are separate topics on:
- Compiling Java source code
- Java deployment including creating JAR files
- Running Java applications
- The Classpath
Here are links to subjects to continue learning and understanding the Java programming language. These subjects are the basics of the Java programming to get you started.
- Primitive Data Types in Java
- Operators in Java
- Strings in Java
- Basic Control Structures in Java
- Classes and Objects in Java
- Arrays in Java
- Java code standards
While Java does not have any support for testing in the standard library, there are 3rd-party libraries that are designed to support testing. The two most popular unit testing libraries are:
- Design patterns for Java are covered in Design Patterns.
- Programming for Android is covered in Android.
- Java Enterprise Edition technologies are covered in Java EE.
- The Oracle JavaFX technologies are covered in JavaFX.
1. In Versions section the end-of-life (free) date is when Oracle will stop posting further updates of Java SE to its public download sites. Customers who need continued access to critical bug fixes and security fixes as well as general maintenance for Java SE can get long term support through Oracle Java SE Support.
|Java SE Version||Code Name||End-of-life (free1)||Release Date|
|Java SE 9 (Early Access)||None||future||2017-07-27|
|Java SE 8||Spider||future||2014-03-18|
|Java SE 7||Dolphin||2015-04-14||2011-07-28|
|Java SE 6||Mustang||2013-04-16||2006-12-23|
|Java SE 5||Tiger||2009-11-04||2004-10-04|
|Java SE 1.4||Merlin||prior to 2009-11-04||2002-02-06|
|Java SE 1.3||Kestrel||prior to 2009-11-04||2000-05-08|
|Java SE 1.2||Playground||prior to 2009-11-04||1998-12-08|
|Java SE 1.1||None||prior to 2009-11-04||1997-02-19|
|Java SE 1.0||Oak||prior to 2009-11-04||1996-01-21|
Creating Your First Java Program
Note: For Java to recognize this as a
public class (and not throw a compile time error), the filename must be the same as the class name (
HelloWorld in this example) with a
.java extension. There should also be a
public access modifier before it.
Naming conventions recommend that Java classes begin with an uppercase character, and be in camel case format (in which the first letter of each word is capitalized). The conventions recommend against underscores (
_) and dollar signs (
To compile, open a terminal window and navigate to the directory of
Note: cd is the terminal command to change directory.
javac followed by the file name and extension as follows:
$ javac HelloWorld.java
It's fairly common to get the error
'javac' is not recognized as an internal or external command, operable program or batch file. even when you have installed the
JDK and are able to run the program from
eclipse etc. Since the path is not added to the environment by default.
In case you get this on windows, to resolve, first try browsing to your
javac.exe path, it's most probably in your
C:\Program Files\Java\jdk(version number)\bin. Then try running it with below.
Previously when we were calling
javac it was same as above command. Only in that case your
OS knew where
javac resided. So let's tell it now, this way you don't have to type the whole path every-time. We would need to add this to our
To edit the
PATH environment variable in Windows XP/Vista/7/8/10:
- Control Panel ⇒ System ⇒ Advanced system settings
- Switch to "Advanced" tab ⇒ Environment Variables
- In "System Variables", scroll down to select "PATH" ⇒ Edit
You cannot undo this so be careful. First copy your existing path to notepad. Then to get the exact PATH to your
javac browse manually to the folder where
javac resides and click on the address bar and then copy it. It should look something like
In "Variable value" field, paste this IN FRONT of all the existing directories, followed by a semi-colon (;). DO NOT DELETE any existing entries.
Now this should resolve.
For Linux Based systems try here.
javac command invokes the Java compiler.
The compiler will then generate a bytecode file called
HelloWorld.class which can be executed in the Java Virtual Machine (JVM). The Java programming language compiler,
javac, reads source files written in the Java programming language and compiles them into
bytecode class files. Optionally, the compiler can also process annotations found in source and class files using the
Pluggable Annotation Processing API. The compiler is a command line tool but can also be invoked using the Java Compiler API.
To run your program, enter
java followed by the name of the class which contains the
main method (
HelloWorld in our example). Note how the
.class is omitted:
$ java HelloWorld
java command runs a Java application.
This will output to your console:
You have successfully coded and built your very first Java program!
Note: In order for Java commands (
javac, etc) to be recognized, you will need to make sure:
- A JDK is installed (e.g. Oracle, OpenJDK and other sources)
- Your environment variables are properly set up
You will need to use a compiler (
javac) and an executor (
java) provided by your JVM. To find out which versions you have installed, enter
java -version and
javac -version on the command line. The version number of your program will be printed in the terminal (e.g.
A closer look at the Hello World program
The "Hello World" program contains a single file, which consists of a
HelloWorld class definition, a
main method, and a statement inside the
class keyword begins the class definition for a class named
HelloWorld. Every Java application contains at least one class definition (Further information about classes).
This is an entry point method (defined by its name and signature of
public static void main(String)) from which the
JVM can run your program. Every Java program should have one. It is:
public: meaning that the method can be called from anywhere mean from outside the program as well. See Visibility for more information on this.
static: meaning it exists and can be run by itself (at the class level without creating an object).
void: meaning it returns no value. Note: This is unlike C and C++ where a return code such as
intis expected (Java's way is
This main method accepts:
- An array (typically called
Strings passed as arguments to main function (e.g. from command line arguments).
Almost all of this is required for a Java entry point method.
- The name
argsis a variable name, so it can be called anything you want, although it is typically called
- Whether its parameter type is an array (
String args) or Varargs (
String... args) does not matter because arrays can be passed into varargs.
Note: A single application may have multiple classes containing an entry point (
main) method. The entry point of the application is determined by the class name passed as an argument to the
Inside the main method, we see the following statement:
Let's break down this statement element-by-element:
|this denotes that the subsequent expression will call upon the |
|this is a "dot operator". Dot operators provide you access to a classes members1; i.e. its fields (variables) and its methods. In this case, this dot operator allows you to reference the |
|this is the name of the static field of |
|this is another dot operator. This dot operator provides access to the |
|this is the name of a method within the PrintStream class. This method in particular prints the contents of the parameters into the console and inserts a newline after.|
|this parenthesis indicates that a method is being accessed (and not a field) and begins the parameters being passed into the |
|this is the String literal that is passed as a parameter, into the |
|this parenthesis signifies the closure of the parameters being passed into the |
|this semicolon marks the end of the statement.|
Note: Each statement in Java must end with a semicolon (
The method body and class body are then closed.
Here's another example demonstrating the OO paradigm. Let's model a football team with one (yes, one!) member. There can be more, but we'll discuss that when we get to arrays.
First, let's define our
Now, let's define our
Why do we use
private here? Well, if someone wanted to know your name, they should ask you directly, instead of reaching into your pocket and pulling out your Social Security card. This
private does something like that: it prevents outside entities from accessing your variables. You can only return
private members through getter functions (shown below).
After putting it all together, and adding the getters and main method as discussed before, we have:
Once again, the
main method inside the
Test class is the entry point to our program. Without the
main method, we cannot tell the Java Virtual Machine (JVM) from where to begin execution of the program.
1 - Because the
HelloWorld class has little relation to the
System class, it can only access