Introduction to Java Programming Language

There are many java versions that have been released. Each version adds a new feature to this powerful language and provides developers useful functionalities. Java SE 8 is recognized as a crucial update to this language as it added many new features and specifications and became the benchmark of an Object-Oriented Programming Language.

Currently, on the date of publishing of this post, Java 17 is the latest Java SE Version available on Oracle Java SE Platform. Java SE 18 is still a work in progress.

• JDK Alpha and Beta (1995)
• JDK 1.0 (23rd Jan, 1996)
• JDK 1.1 (19th Feb, 1997)
• J2SE 1.2 (8th Dec, 1998)
• J2SE 1.3 (8th May, 2000)
• J2SE 1.4 (6th Feb, 2002)
• J2SE 5.0 (30th Sep 2004): This version of Java introduced major changes in the Java programming world. Some of them are:
  • Java Concurrency API
  • Var argument methods
  • Generics
  • Annotations
  • For each loop
  • Enumerations
  • Static import
  • Autoboxing and unboxing etc.
• Java SE 6 (11th Dec 2006)
• Java SE 7 (28th July 2011): Java 7 has the following new major changes:
  • Multi-catch block
  • Support of String in Switch case
  • Try with resources etc.
• Java SE 8 (18th March 2014): Java 8 has introduced major programming paradigms. Some of them are:
  • Lambda Expressions.
  • Functional Interfaces
  • Default methods in the interface.
  • Streams
  • Enhanced Security etc.
• Java SE 9 ( September 21,2017): This version was developed to include better support for multi-gigabyte heaps, better native code integration, a different default garbage collector. Other notable features were:\
  • Provided Money and Currency API.
  • Tight integration with JavaFX.
  • Java implementation of reactive streams.
  • More Concurrency Updates.
  • Provided Java Linker
• Java SE 10 (March 10,2018): This version was released to remove primitive data types and move towards 64-bit addressable arrays to support large data sets for data analytics. Some notable features were:
  • Experimental Java-Based JIT Compiler
  • Garbage-Collector Interface
  • Consolidate the JDK Forest into a Single Repository
• Java SE 11 (September 2018)
• Java SE 12 (March 2019)
• Java SE 13 (September 2019)
• Java SE 14 (March 2020)
• Java SE 15 (September 2020)
• Java SE 16 (March 2021)
• Java SE 17 (September 2021)

Terminologies of Java

For an introduction to Java Programming, it is recommended to have some idea of the basic Java terms to help your learning. Let’s have a quick look at them.

1. Java Development Kit (JDK)

Generally referred to as JDK, this kit provides the functionality required to develop, compile and execute your java application or program. The Java Development Kit can be downloaded from Oracle’s Website. In short, we can say if we want to create, compile or run our java application, then JDK must be installed in our system.

2. Java Runtime Environment (JRE)

The Java Runtime Environment provides the ability to execute our applications at runtime. It comes included with the JDK. JRE installation ensures the smooth running of your java application.

However, it is not responsible for compiling a program. This is a unique aspect of JRE, a user does need to have a complete JDK set up to run/use any Java application, only having the JRE will be sufficient as it provides support through browsers, applets, and other plugins to run a java application.

3. Java Virtual Machine (JVM)

Commonly referred to as JVM, Java Virtual Machine to say is an abstract machine that enables a computer to run java programs as well as programs in other programming languages that are already compiled to java Bytecode. There are two phases to this

• • The Java Compiler compiles the java source code and generates an intermediatory code. This intermediate code is known as the Byte Code.
  • In the executing phase, this Byte Code is interpreted by the Java Interpreter and can be executed on any machine running a JVM. So, JVM reifies execution and the JRE provides the environment for it.

To summarize the role of each, refer to the diagram below:

4. Byte Code

As discussed above, the Java Compiler compiles the Java Source Code into an intermediate code. This is generally saved as a .class File. This intermediate code is known as Byte Code and is an important aspect of Java as this makes the Language Platform-Independent. This is a machine-independent code and can be read or executed by any machine running a JVM.

5. Garbage Collection

Garbage Collection eases the work of a programmer. Its main job is to deallocate or delete unused references or objects. Thus the programmer need not worry about deleting occupied memory resources or memory management. If the reference is not used over a long period of time, the garbage collector will automatically delete it.

These are the important terminologies every beginner in Java should know as they will lay the foundation of core principles of Java.

Features of Java:

• Simple:  Java is easy to learn. It does not include concepts of pointers and operator overloading that were available in C++.
• Object-Oriented: You can model everything into an object which has data and behavior. Java has incorporated various object-oriented concepts such as Abstraction, Encapsulation, Polymorphism, and inheritance.
• Platform independence:  Java is a write-once, run-anywhere language. Once you compile java code, you can run it on any machine. For example: If you compile your code on Windows OS, you can easily run the same bytecode in Linux.
• Portable: Java byte can be portable to any platform and can be executed on any platform.
• Multi-threading: Java has provided a multithreading feature that will help you to execute the various tasks in parallel. It has introduced an executor framework that is more robust and easy to use.
• High performance: Java can not be as fast as C and C++ as it is interpreted language but it has provided various features such as Just in time compiler to increase performance.
• Secure: Unlike C, there is no concept of pointers in Java, as the user can try to access the memory reference of certain objects which might pose a security threat to those objects. This is why Java has eliminated pointers in use which makes some security flaws impossible to exploit and makes it secure.