Introduction to Java

Learning outcome: Explain what Java is, why it is used, how a Java program runs, and how to write, compile, and execute a first program.

Java is a high-level, class-based programming language with strong object-oriented support, designed for building portable and reliable software. It is used in Android applications, enterprise systems, banking platforms, e-commerce systems, desktop tools, and server-side services.

Java was created at Sun Microsystems by a team led by James Gosling and released publicly in 1995. Its central design promise is still its most important idea: write a program once, compile it once, and run it on any system that has a compatible Java Virtual Machine.

Why Java Matters

Java remains important because it balances readability, strong tooling, object-oriented design, and platform independence. Students coming from C or C++ will recognize braces, semicolons, data types, expressions, and control structures, but Java changes the execution model and removes several low-level responsibilities.

Key reasons Java is widely used:

How a Java Program Runs

Java does not compile source code directly into machine code for one operating system. Instead, Java source code is compiled into bytecode. Bytecode is stored in .class files and is executed by the Java Virtual Machine.

In simple terms: Bytecode is a recipe written in a shared kitchen language. The recipe itself belongs to no particular kitchen; every kitchen keeps a cook — the JVM — who reads that language and works the local stove.

The execution flow is:

1. Write source code in a .java file.
2. Compile the source with javac.
3. The compiler produces .class bytecode.
4. The JVM loads and executes the bytecode.
5. The program produces output.

JDK, JRE, and JVM

These terms are related but distinct. Older teaching diagrams often show the JDK containing a separately installed JRE, which contains the JVM. For modern JDKs, it is more accurate to treat the JRE as the runtime concept—a JVM plus the libraries and supporting files required by an application—while the JDK supplies both development tools and a runtime image.

In simple terms: The JVM is the engine, the JRE is the whole car you can drive, and the JDK is that car plus the workshop and tools for building new ones. Writing programs needs the workshop; only running a finished program needs just the car.

For this course, install a JDK. The conceptual distinction still matters: the JVM is the execution engine, a runtime environment supplies what a Java application needs to run, and the JDK adds compilation and development tools.

Inside the JVM Execution Pipeline

After compilation produces a .class file, several components inside the JVM cooperate to load, verify, and execute the bytecode.

In simple terms: Loading, verifying, and executing is airport security for code. The class loader brings the luggage in, the verifier checks that nothing dangerous is inside, and only then is the bytecode allowed through to run.

Platform Independence and WORA

Java's platform independence comes from bytecode. The .class file does not belong to Windows, Linux, or macOS. Each operating system has its own JVM, and that JVM translates the same bytecode for the local machine.

In simple terms: The .class file is one document, and each operating system supplies its own translator. Write it once, and Windows, Linux, and macOS each read it aloud in their own language.

The bytecode is platform-neutral; the JVM implementation is platform-specific. Complete applications must also avoid incompatible native libraries, operating-system assumptions, and unavailable dependencies if they are to remain portable.

Setting Up the Environment

JDK 17 is the baseline for the core examples and laboratory work. JDK 21 may also be used; features that require a later release are marked Enrichment and are not required for the core exercises.

Check the installation from a terminal:

java -version
javac -version

If both commands print version numbers, Java is installed and available from the system path. If the terminal reports that the command is not found, the JDK bin folder is probably not configured in the PATH.

Recommended editors for beginners:

How to Read the Code Samples

Java blocks appear in two clearly different forms:

• A block containing a top-level public class is a complete source-file example. Save it in a file whose name matches that class, then compile and run it as shown.
• A short block containing only declarations, statements, or a method demonstrates one local idea. It is a fragment intended to be placed inside the surrounding class or method described by the text; it is not presented as a standalone program.

Invalid code is commented out or explicitly labelled as invalid. Traditional switch examples show every required break;, except where the text intentionally demonstrates fall-through.

First Java Program

Create a file named exactly HelloWorld.java.

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Compile and run:

javac HelloWorld.java
java HelloWorld

Output:

Hello, World!

Line-by-line meaning:

Command-Line Arguments

The String[] args part of main stores command-line arguments. Each argument arrives as a String, even if it looks like a number. Numeric arguments must be converted before arithmetic.

In simple terms: Command-line arguments arrive the way a form arrives filled in by hand: everything is text. Typing 25 at the terminal gives the characters '2' and '5', not the number 25, until the program converts them.

public class AddArgs {
    public static void main(String[] args) {
        if (args.length != 2) {
            System.out.println("Usage: java AddArgs <first> <second>");
            return;
        }

        try {
            int first = Integer.parseInt(args[0]);
            int second = Integer.parseInt(args[1]);
            System.out.println(first + second);
        } catch (NumberFormatException exception) {
            System.out.println("Both arguments must be valid integers.");
        }
    }
}

Compile and run:

javac AddArgs.java
java AddArgs 10 20

Output:

30

Common Mistakes

Practice

Problem 1: Print Your Details

Write a program that prints your name, course, and college on separate lines.

public class MyDetails {
    public static void main(String[] args) {
        System.out.println("Name   : Aarav Sharma");
        System.out.println("Course : Project Based Learning in Java");
        System.out.println("College: Chandigarh University");
    }
}

Problem 2: print vs println

Predict the output before running the program.

public class PrintDemo {
    public static void main(String[] args) {
        System.out.print("Java ");
        System.out.print("is ");
        System.out.println("fun.");
        System.out.println("Welcome!");
    }
}

Output:

Java is fun.
Welcome!

Problem 3: A Tiny Calculation

public class Sum {
    public static void main(String[] args) {
        int a = 12;
        int b = 8;
        int total = a + b;
        System.out.println("Sum of " + a + " and " + b + " = " + total);
    }
}

Quick Check

1. What is bytecode?
2. Which tool converts .java source into .class bytecode?
3. What does the JVM do?
4. Why can the same .class file run on different operating systems?
5. What is the difference between print and println?

Lecture Quiz

Summary

Java is a portable, class-based language with strong object-oriented support. A program is written as source code, compiled by javac into bytecode, and executed by the JVM. A modern JDK supplies both the development tools and a runtime image; “JRE” describes the runtime environment needed to run Java code.