Programming Fundamentals & Java Architecture

(Complete Notes | Beginner to Advanced | Professional & Exam-Oriented | SEO-Optimized)

This module is designed for:

• Students searching what is programming and introduction to Java
• Learners looking for Java architecture explained and JDK vs JRE vs JVM
• Users searching Java compilation process and what is bytecode in Java
• Candidates preparing for competitive computer science exams (BCA, MCA, GATE, UGC NET)
• Beginners starting their first Java programming course

---

1. Introduction to Programming

1.1 What is Programming?

Programming is the process of designing and writing a precise sequence of instructions that a computer can understand and execute to perform a specific task or solve a problem.

A computer is an incredibly fast but fundamentally unintelligent machine — it cannot think, reason, or make decisions on its own. It only follows the instructions given to it, exactly as written, step by step. These instructions are written in a programming language — a formal language with strict syntax and rules that both humans can write and computers can process.

Why Do We Need Programming?

Everything digital — from the calculator app on your phone to Google Search to self-driving cars — exists because someone wrote a program.

What Does a Program Look Like?

A program is a collection of instructions written in a specific syntax that solves a defined problem.

Real-world analogy: Think of a recipe for cooking. The recipe has:

• A list of ingredients (input)
• Step-by-step instructions (process)
• The final dish (output)

Similarly, a program takes input, processes it using instructions, and produces output.

Example: Calculate total marks of a student

When these steps are written in Java (or any programming language), it becomes a program.

The Complete Programming Process

---

1.2 Algorithm & Flowchart

What is an Algorithm?

An algorithm is a finite, well-defined sequence of step-by-step instructions designed to solve a specific problem or accomplish a particular task.

Think of an algorithm as a recipe for solving a problem — it tells you exactly what to do, in what order, and when to stop.

Five Essential Properties of an Algorithm

Algorithm Example: Calculate Area of a Rectangle

Algorithm Example: Find Largest of Three Numbers

Key Point: Algorithms are language-independent — the same algorithm can be implemented in Java, Python, C++, or any other language.

---

What is a Flowchart?

A flowchart is a graphical/diagrammatic representation of an algorithm using standardized symbols connected by arrows (flow lines) that show the sequence and flow of operations.

Standard Flowchart Symbols

Why Use Flowcharts?

---

1.3 Compilation vs Interpretation

When you write code in a high-level language, the computer cannot understand it directly. It must be translated into machine code (binary: 0s and 1s). There are two main approaches:

Compilation

Interpretation

Java's Hybrid Approach — The Best of Both Worlds

Java uses both compilation and interpretation, making it unique:

This hybrid approach gives Java:

• Compile-time error checking (catches errors early)
• Platform independence (bytecode runs on any JVM)
• Good performance (JIT optimizes hot code paths)

---

1.4 Low-Level vs High-Level Languages

Language Hierarchy

Java is a high-level language — it uses English-like keywords (class, public, void, if, while) making it readable and maintainable.

---

1.5 Structured vs Object-Oriented Programming

Four Pillars of OOP (Preview — Detailed in Module 3)

Java is primarily an Object-Oriented language — everything in Java revolves around classes and objects.

---

2. Introduction to Java

2.1 History of Java

Key Facts for Exams:

• Creator: James Gosling (Father of Java)
• Company: Sun Microsystems (now Oracle)
• Year: 1995
• Original name: Oak
• Motto: WORA — Write Once, Run Anywhere

---

2.2 Java Editions

For beginners and most competitive exams, Java SE (Core Java) is the focus.

---

2.3 Features of Java — Complete List

Memory Trick for Features

---

3. Java Architecture — The Most Important Section

Understanding Java architecture is critical for exams and interviews. This section explains how Java programs are compiled, loaded, verified, and executed.

---

3.1 JDK (Java Development Kit)

The JDK (Java Development Kit) is a comprehensive software development environment used to develop Java applications and applets. It is a physical bundle of software that includes everything you need to write, compile, and debug Java code.

1. Core Components of JDK

The JDK essentially consists of two main parts:

1. JRE (Java Runtime Environment): Used to run Java programs.
2. Development Tools: Used to build Java programs.

2. Essential Development Tools

The JDK includes several command-line tools that every Java developer must know:

3. Why do we need the JDK?

Imagine you are a chef (the Developer).

• The JRE is like the Kitchen (the environment where the food is cooked and served).
• The JDK is the Kitchen + Chef's Toolkit (knives, pans, recipe books).

To run a restaurant (run an app), you just need a kitchen (JRE). But to be a chef and create new dishes (develop apps), you must have the full toolkit (JDK).

4. The Hierarchy

Mathematically, the relationship is often summarized as: JDK = JRE + Development Tools (And as we'll see in the next section, JRE = JVM + Class Libraries)

---

3.2 JRE (Java Runtime Environment)

The JRE (Java Runtime Environment) is a part of the Java Development Kit (JDK) that contains everything required to run a Java application. It is the implementation of the Java Virtual Machine (JVM) that actually exists on your computer.

1. What is inside the JRE?

The JRE is composed of three primary components:

1. JVM (Java Virtual Machine): The engine that executes the bytecode.
2. Class Libraries: A collection of pre-written code (like java.lang, java.util) that your program needs to function.
3. Supporting Files: Configuration and property files used by the JVM.

2. Component Functions

3. How JRE Works (The Bridge)

Think of the JRE as a Language Translator Experience.

• The Bytecode is a book written in a foreign language.
• The JRE is the Reading Room that provides the Translator (JVM) and the Dictionary (Class Libraries).
• Without the JRE, your computer would see the .class file but wouldn't have the tools or the environment to understand or play it.

4. The Hierarchy

As mentioned before: JRE = JVM + Class Libraries + Supporting Files

---

3.3 JVM (Java Virtual Machine)

The JVM (Java Virtual Machine) is the heart of the Java technology. It is an abstract computer that runs on your real computer. It provides a runtime environment in which Java bytecode can be executed.

JVM Architecture — The Internal Subsystems

To understand how Java runs, you must understand the three main subsystems of the JVM:

1. Class Loader Subsystem

This subsystem is responsible for loading, linking, and initializing the class files.

• Loading: Reads the .class file and stores binary data in the Method Area.
• Linking: Performs Verification (checks if bytecode is valid), Preparation (allocates memory for static variables), and Resolution (replaces symbolic references with actual memory references).
• Initialization: Assigns actual values to static variables and executes static blocks.

2. Runtime Data Areas (Memory Management)

JVM divides its memory into five main areas to manage data efficiently:

3. Execution Engine

This is where the actual work happens. It "talks" to the hardware.

• Interpreter: Reads bytecode and executes it line-by-line. It is fast to start but slow for repeated code.
• JIT (Just-In-Time) Compiler: Identifies "hot spots" (code that runs repeatedly) and compiles them into Native Machine Code for high performance.
• Garbage Collector (GC): Automatically identifies objects that are no longer in use and deletes them to free up memory.

4. Native Method Interface (JNI)

The JNI is a bridge that allows Java code to interact with libraries written in other languages like C or C++. This is useful for high-performance graphics or interacting directly with hardware.

Summary: The Software CPU

The JVM is essentially a software-based CPU that translates your generic Bytecode into the specific "language" of your computer's hardware.

---

3.4 The JDK-JRE-JVM Hierarchy

The relationship is:

Visual hierarchy: JDK contains JRE, and JRE contains JVM.

---

3.5 Bytecode — Java's Secret to Portability

Java's most famous motto is "Write Once, Run Anywhere" (WORA). The "secret" that makes this possible is Bytecode.

1. What is Java Bytecode?

Bytecode is a highly optimized set of instructions designed to be executed by the Java Virtual Machine (JVM) rather than the physical CPU.

• When you compile a C or C++ program, it is converted directly into Machine Code (specific to Windows, Linux, or Mac).
• When you compile a Java program, the javac compiler converts it into Bytecode (a .class file).

2. The Compilation & Execution Process

To understand portability, let's look at the lifecycle of a Java program:

3. Why is Bytecode the "Secret" to Portability?

Imagine you are writing a book and want people in China, India, and France to read it.

• The C++ Way: You write three different books in three different languages.
• The Java Way: You write the book in a special "Universal Language" (Bytecode). You then give everyone a "Translator" (the JVM). Whether the reader is in China or France, as long as they have the JVM translator, they can read your book perfectly.

4. Comparison: Machine Code vs. Bytecode

---

3.6 JIT (Just-In-Time) Compiler

The JIT (Just-In-Time) Compiler is the secret weapon of the JVM that makes Java programs run at lightning speed. It is a part of the Execution Engine that drastically improves the performance of Java applications at runtime.

1. Why do we need JIT?

Computers have two main ways to run high-level code:

• Interpreter: Starts quickly but runs slowly because it translates every line of code as it runs, even if that line runs 1,000 times (like in a loop).
• Compiler (C++/Rust): Slow to start (needs time to compile everything) but runs very fast because it produces machine code once.

Java uses a Hybrid Approach: It uses the Interpreter to start the program instantly and the JIT Compiler to speed it up as it runs.

2. The "Hotspot" Concept

The JVM monitors your code while it's running. It identifies "Hotspots"—sections of code that are executed frequently (like a loop that runs 50,000 times).

When a hotspot is detected, the JIT Compiler steps in and:

1. Translates that specific bytecode into Native Machine Code (the CPU's native language).
2. Stores that native code in a special cache.
3. The next time that code is needed, the CPU runs the native code directly without any translation.

3. Comparison: Interpreter vs. JIT Compiler

4. Adaptive Optimization

The JIT doesn't just compile; it optimizes. It analyzes the running program and makes "guesses" on how to make the code faster (like inlining small methods or removing redundant checks). If the guess is wrong, it can even "de-optimize" and go back to the interpreter to maintain safety.

Summary

The JIT Compiler ensures that Java achieves the best of both worlds: the Portability of an interpreted language and the Performance of a compiled language.

---

3.7 Class Loader — Loading Classes into Memory

The Class Loader is a crucial subsystem of the JVM that is used to load class files dynamically at runtime. It is the first component that touches your .class files and brings them into the JVM's memory.

1. Why do we need it?

In many languages (like C), all code is loaded at once when the program starts. Java is different—it loads classes on-demand (only when they are needed for the first time). This makes Java more memory-efficient and flexible.

2. The Three Built-in Class Loaders

Java uses a hierarchy of three loaders to ensure security and organization:

3. Delegation Hierarchy Model

When a class needs to be loaded, Java follows a unique "Ask-the-Parent-First" rule:

1. Request: You call a class.
2. Delegation: The Application Loader asks the Extension Loader. The Extension Loader asks the Bootstrap Loader.
3. Search: If the Bootstrap Loader finds it, it loads it. If not, the request comes back down to the Extension, then finally to the Application loader.

4. The Three Principles

• Delegation: Passes the loading request to the parent.
• Visibility: A child loader can see classes loaded by parent loaders, but a parent cannot see classes loaded by a child.
• Uniqueness: A class loaded by a parent should not be re-loaded by a child.

---

3.8 Garbage Collection — Automatic Memory Management

One of Java's biggest advantages is that you never have to "clean up" the memory yourself. The Garbage Collector (GC) is a background process that automatically manages memory for you.

1. What is Garbage Collection?

In older languages like C or C++, if you create a variable, you must manually delete it when you're done. If you forget, your computer runs out of memory (a Memory Leak). In Java, the GC automatically identifies objects that are no longer being used and deletes them to free up space.

2. How does it work? (The "Mark and Sweep" Concept)

The GC follows a simple but powerful process:

1. Mark: It traces all objects starting from the "roots" (active variables). Objects that are still reachable are "marked" as alive.
2. Sweep: Any object that was not marked is considered "garbage" and is "swept" away (deleted).

3. When is an Object eligible for GC?

An object becomes "garbage" when it can no longer be reached by your code. This happens if:

• The variable is set to null (e.g., student = null;).
• The variable goes out of scope (e.g., a variable inside a method after the method finishes).
• The object is "orphaned" (no one points to it anymore).

4. Comparison: Java vs. C++ Memory Management

5. Can we control the GC?

No. While you can "request" the GC to run using System.gc(), the JVM usually ignores this request and runs it only when it feels necessary.

---

4. Java Program Structure

4.1 Basic Structure of a Java Program

Every Java program follows this structure:

4.2 Understanding Each Component

4.3 The Complete Compilation and Execution Process

4.4 Important Rules

---

5. Setting Up Java Development Environment

5.1 Installing JDK

5.2 Popular Java IDEs

---

Practice Lab