Introduction to JAVA

Module 1: Overview of Java

1.1 Introduction to Java

Definition of Java

Java is a versatile, object-oriented, high-level programming language developed by Sun Microsystems (now owned by Oracle Corporation) in the mid-1990s. It was designed with the primary goal of being platform-independent, enabling developers to write code that could run on any device or platform without modification. Java has since become one of the most widely used and influential programming languages, finding applications in various domains such as web development, mobile applications, enterprise software, and embedded systems.

Key characteristics that define Java include:

Object-Oriented: Java is based on the object-oriented programming paradigm, emphasizing the use of classes and objects. This promotes modularity, reusability, and a structured approach to software development.

Platform-Independent: Java achieves platform independence through the "Write Once, Run Anywhere" (WORA) principle. Java programs are compiled into an intermediate form called bytecode, which can be executed on any device with a Java Virtual Machine (JVM), regardless of the underlying hardware and operating system.

Simple and Readable: Java was designed to be easy to learn and use. Its syntax is derived from C and C++, with a focus on eliminating complex features that might lead to errors. This simplicity contributes to the readability of Java code.

Portable: Java's portability is a result of its platform independence. A Java program compiled on one system can be transferred to another without modification, as long as both systems have a compatible JVM.

Distributed Computing: Java supports the creation of distributed applications by providing a rich set of libraries and APIs for network programming. This has made Java a popular choice for developing enterprise-level, distributed systems.

Multithreaded: Java supports multithreading, allowing concurrent execution of multiple threads within the same program. This is particularly useful for developing applications that require parallel processing and improved performance.

Robust and Secure: Java incorporates features for automatic memory management (garbage collection), exception handling, and type-checking, making it robust and less prone to errors. Additionally, Java's security features, such as the sandboxing of applets, enhance its security.

Dynamic: Java supports dynamic loading of classes, dynamic linking, and runtime interpretation, providing flexibility and adaptability to changing runtime conditions.

 

History and Evolution of Java

1. Java:

Java, originally developed by James Gosling and Mike Sheridan at Sun Microsystems in the early 1990s, was envisioned as a programming language for consumer electronic devices. Its development aimed to address the challenges of building software for a diverse range of devices and platforms.

1991: The project, initially named "Oak," began as an effort to create a platform-independent, object-oriented language for use in embedded systems.

1995: The official release of Java was marked by the introduction of Java 1.0. This version included key features like the applet, a small program designed to run within a web browser, which played a crucial role in popularizing Java on the internet.

1996: Java 1.1 brought significant improvements, including inner classes, JavaBeans, and the Abstract Window Toolkit (AWT) for building graphical user interfaces.

1998: The release of Java 2 (J2SE 1.2) introduced the Java Naming and Directory Interface (JNDI) and Swing API for more sophisticated GUI development.

2. Advanced Java:

While "Advanced Java" is a term often used to refer to more advanced features within the Java language, it is crucial to note that there isn't a distinct version labeled as "Advanced Java." The term generally encompasses advanced concepts and technologies associated with Java development. Let's explore the evolution of advanced concepts:

Enterprise JavaBeans (EJB):

In the late 1990s, the Java 2 Platform, Enterprise Edition (J2EE), introduced Enterprise JavaBeans, a component architecture for building scalable and distributed enterprise applications.

Java 2 Platform, Micro Edition (J2ME):

This platform, introduced in the early 2000s, targeted mobile and embedded systems, allowing Java to be used for developing applications for devices with limited resources.

Java 2 Platform, Standard Edition (J2SE):

The evolution still continued with the introduction of various versions, each bringing enhancements and new features. Notable releases include J2SE 5.0 (introducing generics and metadata annotations) and Java SE 8 (with the inclusion of lambda expressions and the Stream API).

Java Platform, Enterprise Edition (Java EE):

The enterprise edition evolved to simplify and enhance the development of large-scale enterprise applications. It incorporated technologies like Servlets, JSP (JavaServer Pages), and JPA (Java Persistence API).

JavaFX:

As Swing aged, JavaFX was introduced as a modern alternative for building rich client applications with features like hardware-accelerated graphics and improved multimedia support.

Java SE 9 and Beyond:

The Java SE platform continued to evolve with features like the module system (Project Jigsaw) introduced in Java SE 9, followed by a regular release cadence (Java SE 10, 11, and so on).

Key features: Simple, Object-oriented, Portable, Distributed, Multithreaded, Robust, and Secure

1.2 Java Development Kit (JDK) Installation

Steps to Download and Install Java Development Kit (JDK)

Installing the Java Development Kit (JDK) is a fundamental step in setting up a Java development environment. The JDK includes tools necessary for compiling, debugging, and running Java applications. Below are detailed steps for downloading and installing the JDK on a Windows system. For other operating systems, the general process is similar.

Step 1: Access the Oracle JDK Website

Open a web browser and navigate to the official Oracle JDK download page: Oracle JDK Download Page.

Step 2: Choose the JDK Version

Select the appropriate JDK version for your development needs. You may choose between the Oracle JDK or OpenJDK, depending on your preferences.

Step 3: Accept the License Agreement

Scroll down to find the list of available downloads. Read and accept the license agreement by clicking the checkbox next to "I reviewed and accept the Oracle Technology Network License Agreement for Oracle Java SE" and click the download link.

Step 4: Select the Operating System

Choose the download link corresponding to your operating system. For Windows, this might be a .exe file.

Step 5: Download the JDK Installer

Click the download link to initiate the download of the JDK installer file. Save the file to a location on your computer.

Step 6: Run the JDK Installer

Once the download is complete, locate the installer file and double-click it to run the installer.

Step 7: Follow the Installation Wizard

The installation wizard will guide you through the installation process. Follow the on-screen instructions:

Choose the installation location.

Optionally, you may be asked to select additional components to install, such as the public JRE. Choose according to your preferences.

Allow the installer to complete the installation.

Step 8: Set Environment Variables (Optional)

After installation, you may need to set the PATH environment variable to include the bin directory of the JDK. This step is essential for the system to recognize Java commands.

Step 9: Verify Installation

Open a command prompt or terminal window and type the following commands to verify the installation:

These commands should display the installed Java and Java Compiler versions, confirming a successful installation.

Setting up Environment Variables for Java Development Kit (JDK)

Configuring environment variables is a crucial step after installing the Java Development Kit (JDK). This ensures that the system recognizes Java commands globally. Below are detailed steps for setting up environment variables on a Windows system. The process is slightly different for other operating systems.

Step 1: Find JDK Installation Directory

Locate the directory where JDK is installed. The default installation path for JDK on Windows is typically something like C:\Program Files\Java\jdk<version>.

Step 2: Copy JDK Path

Copy the path to the JDK installation directory. This path will be used to set the JAVA_HOME environment variable.

Step 3: Set JAVA_HOME Variable

Right-click on the "This PC" or "Computer" icon on your desktop or in the File Explorer, and select "Properties."

Click on "Advanced system settings" on the left.

In the System Properties window, click the "Environment Variables..." button.

In the Environment Variables window:

Under the "System variables" section, click "New."

Enter JAVA_HOME as the variable name.

Paste the copied JDK installation path as the variable value.

Click "OK" to save.

Step 4: Update Path Variable

In the same Environment Variables window:

Under the "System variables" section, find and select the "Path" variable.

Click "Edit."

In the Edit Environment Variable window:

Click "New."

Enter %JAVA_HOME%\bin as the new entry.

Click "OK" to close each window.

Step 5: Verify Configuration

Open a new command prompt window and type the following commands to verify the configuration:

This should display the installed Java version, confirming that the environment variables are set up correctly.

 

1.3 First Java Program

1.4 Java Virtual Machine (JVM)

Explanation of JVM

The Java Virtual Machine (JVM) is a crucial component of the Java Runtime Environment (JRE), responsible for executing Java bytecode. The JVM is a virtualized execution environment that allows Java applications to run on any device or operating system without modification. It abstracts the underlying hardware and provides a consistent platform for Java programs.

Key Components:

Class Loader:

The Class Loader is responsible for loading class files into the JVM. It takes bytecode and converts it into a runtime class. There are three types of class loaders: Bootstrap, Extension, and Application.

Bytecode Verifier:

Before execution, the bytecode verifier ensures that the loaded bytecode adheres to the Java language specifications. It checks for illegal code that could potentially harm the JVM or violate the security of the system.

Interpreter:

The Interpreter reads and executes the Java bytecode line by line. While this approach is straightforward, it can be relatively slow. The JVM may use Just-In-Time (JIT) compilation to address this issue (explained later).

JIT Compiler:

The Just-In-Time Compiler translates bytecode into native machine code just before execution. This can significantly improve the performance of Java applications by reducing the overhead of interpreting bytecode repeatedly.

Runtime Data Areas:

The JVM manages various runtime data areas during program execution, including the Method Area, Heap, Stack, and PC (Program Counter) Register. These areas store information such as loaded class structures, objects, and method information.

Execution Engine:

The Execution Engine executes the compiled bytecode. It consists of the Interpreter and the JIT Compiler. The Interpreter executes code line by line, while the JIT Compiler dynamically compiles bytecode into native machine code for improved performance.

 

Role in Java execution

The Java Virtual Machine (JVM) plays a critical role in the execution of Java programs. Its primary responsibilities include managing the execution of Java bytecode, providing a runtime environment, and ensuring platform independence. Here's a detailed breakdown of the JVM's role in Java execution:

1. Loading of Classes:

The JVM is responsible for loading Java classes into its runtime environment. The process involves locating and reading class files from the file system or network, and then storing the class information in the Method Area of the JVM.

2. Bytecode Verification:

Before execution, the JVM verifies the loaded bytecode to ensure that it adheres to the rules and constraints defined by the Java language specifications. This step is crucial for maintaining the security and integrity of the JVM.

3. Memory Management:

The JVM manages memory during program execution. It allocates memory for various runtime data areas, including the Heap for object storage, the Stack for local variables and method calls, and the Method Area for class structures and static variables.

4. Just-In-Time Compilation (JIT):

The JVM employs a Just-In-Time Compiler to translate bytecode into native machine code. This compilation happens dynamically at runtime, improving the performance of Java applications. The JIT Compiler optimizes frequently executed code, reducing the need for interpretation and enhancing overall execution speed.

5. Interpreter:

The JVM includes an interpreter that reads and executes Java bytecode line by line. While interpreting bytecode can be slower than native execution, it allows for platform independence, as the same bytecode can run on any system with a compatible JVM.

6. Execution Engine:

The Execution Engine is a core component of the JVM responsible for executing Java bytecode. It consists of both the interpreter and the JIT Compiler. The interpreter provides a quick startup for the program, and the JIT Compiler improves long-term performance by translating bytecode into optimized native machine code.

7. Garbage Collection:

The JVM features a Garbage Collector that automatically identifies and collects unreferenced objects in the Heap. This helps prevent memory leaks and ensures efficient memory utilization.

8. Exception Handling:

The JVM manages runtime exceptions, ensuring that programs respond appropriately to unexpected situations. It includes mechanisms for throwing, propagating, and catching exceptions.

9. Platform Independence:

One of the key objectives of the JVM is to provide platform independence for Java programs. By executing bytecode instead of native machine code, Java applications can run on any device or operating system with a compatible JVM, promoting the "Write Once, Run Anywhere" philosophy.

Additional Resources

1. Books:
• "Java: The Complete Reference" by Herbert Schildt
• "Effective Java" by Joshua Bloch
2. Online Courses:
• Coursera - Java Programming and Software Engineering Fundamentals
3. Video Tutorials:
• Java Tutorial for Beginners by Programming with Mosh
• Java Programming Tutorial - Full Course for Beginners by CodeWithChris
4. Websites:
• Oracle Java Documentation
• GeeksforGeeks - Java Programming Language