Module 01 — Welcome to Java

1. What Is Java?

Java is a programming language — one of the most widely used on the planet. You will use it to build applications, process data, write server-side logic, and, starting right now, learn how programming actually works.

Java was created by James Gosling at Sun Microsystems and first released in 1995. The central idea: write code once, run it anywhere. Sun Microsystems was acquired by Oracle in 2010, and Oracle maintains Java today.

Why Java?

There are hundreds of programming languages. Here is why Java is worth your time this semester:

• It runs everywhere. Java is on billions of devices — phones, servers, ATMs, smart cards, Blu-ray players. Android apps were originally written in Java.
• Job market. Java consistently ranks in the top three most in-demand programming languages. Companies like Amazon, Google, Netflix, and LinkedIn run Java on their back-end servers.
• It builds good habits. Java forces you to be explicit and structured. Those habits transfer to every other language you learn afterward.
• Platform independence. You write one program, and it runs on Windows, Mac, or Linux without changing a single line of code.

2. How Java Works

Computers do not understand English or Java. They only understand binary — ones and zeros. Java uses a two-step process: compilation into bytecode, then execution by the JVM.

Step 1: Write Source Code

You type your program into a file with a .java extension. This is called source code — the human-readable version of your program. A file named Hello.java is a source file.

Step 2: Compile to Bytecode

You run a tool called javac (the Java compiler). It reads your .java file and produces a .class file containing bytecode. Bytecode is not machine code, and not source code — it is a platform-neutral middle format.

Step 3: The JVM Executes the Bytecode

The Java Virtual Machine (JVM) reads the bytecode and translates it into instructions your specific computer can execute. Every operating system has its own JVM. That is what makes "write once, run anywhere" real.

  Source Code          Compiler         Bytecode          JVM Executes
  Hello.java   --->    javac    --->  Hello.class  --->   java Hello
  (you write)       (you run javac)  (auto-created)    (you run java)

How Is This Different from C?

In a language like C, the compiler translates source code directly to machine code for one specific OS. A C program compiled on Windows will not run on Linux without recompiling. Java's bytecode plus JVM solves that — the same .class file runs on any platform with a JVM.

3. The Java Development Kit (JDK)

Before you can write and run Java programs, you need the JDK (Java Development Kit) installed. You will hear three acronyms: JDK, JRE, and JVM. They nest inside each other like containers.

You always install the JDK. It contains the JRE, which contains the JVM. Think of nesting containers: JVM smallest, inside JRE, which is inside JDK.

What Is Inside the JDK?

• javac — The compiler. Turns .java source files into .class bytecode.
• java — The launcher. Starts the JVM and runs your compiled program.
• jar — Packages compiled files into a single distributable archive.
• javadoc — Generates HTML documentation from source code comments.
• Standard class library — Thousands of pre-built classes for I/O, math, networking, and more.

4. Setting Up Your Environment

You have two main options: an IDE or the command line. You will use both this semester.

IDEs

An IDE (Integrated Development Environment) combines code editor, compiler, debugger, and project manager in one program. Your main options:

• IntelliJ IDEA — The most popular Java IDE. Community Edition is free. Recommended for this course.
• Eclipse — Free and open-source. Common in enterprise environments.
• VS Code — Lightweight editor with a Java extension pack.

Not ready to install? Replit (replit.com) and JDoodle (jdoodle.com) run Java in your browser with zero setup.

Compile and Run from the Command Line

# Step 1: Compile your source file
javac Hello.java

# Step 2: Run the compiled program (no .class extension)
java Hello

Verify Your Installation

java -version
openjdk version "17.0.9" 2023-10-17

javac -version
javac 17.0.9

Version numbers mean you are ready. command not found means the JDK is not on your PATH — bring that to class and we will fix it together.

5. Your First Program

Every programming course starts with Hello World. The program is trivial — the point is learning the structure Java requires. Write it, compile it, run it, then take it apart line by line.

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

Save this as Hello.java, then run:

javac Hello.java
java Hello
Hello, World!

You just ran your first Java program. Now let's break down every single line.

Line 1: public class Hello {

This declares a class named Hello. In Java, all code lives inside a class — no exceptions. The keyword public means this class is visible and accessible from anywhere. The opening curly brace { marks where the class body begins.

Line 2: public static void main(String[] args) {

This is the main method. When you run java Hello, the JVM searches for this exact signature and starts execution there. Memorize it. Write it exactly this way every time.

Line 3: System.out.println("Hello, World!");

This prints a line of text to the console. Here is what each piece does:

• System — A built-in Java class representing the running environment
• out — The output stream connected to your terminal window
• println — Short for "print line" — prints text and then moves the cursor to the next line
• "Hello, World!" — The text to display, in double quotes (a String literal)
• ; — The semicolon ending the statement

Lines 4 and 5: The Closing Braces

The two closing braces close the main method and then the class, in that order. Every opening brace needs a matching closing brace. Count them — mismatched braces are one of the most common beginner mistakes.

6. Java Syntax Basics

Java enforces its rules without exceptions. Break them and the compiler stops and tells you exactly where. Here are the four core syntax rules you need right now.

Rule 1: Java Is Case-Sensitive

Uppercase and lowercase letters are completely different. System is not system. main is not Main. This applies to class names, method names, variable names, and all built-in keywords.

// CORRECT
System.out.println("Hello");

// WRONG - lowercase 's' on System causes a compile error
system.out.println("Hello");

Rule 2: Every Statement Ends with a Semicolon

A semicolon is the period at the end of a sentence. Every executable statement needs one. Forget it and the compiler flags the next line with a confusing error.

// CORRECT
System.out.println("Hello");

// WRONG - missing semicolon causes a compile error on the line below
System.out.println("Hello")

Rule 3: Curly Braces Define Blocks

Opening braces { and closing braces } mark the start and end of code blocks for classes, methods, loops, and conditions. Every opening brace must have a matching closing brace. Count them carefully.

// CORRECT - balanced braces
public class Demo {
    public static void main(String[] args) {
        System.out.println("Works!");
    }   // closes method
}       // closes class

// WRONG - missing closing brace for the class
public class Demo {
    public static void main(String[] args) {
        System.out.println("Works!");
    }
// Error: reached end of file while parsing

Rule 4: Whitespace Does Not Matter (But Use It Anyway)

Java ignores extra spaces, tabs, and blank lines. Both of these compile identically — but only one of them is acceptable:

// Compact (valid, but completely unreadable)
public class Demo{public static void main(String[]args){System.out.println("Hi");}}

// Properly indented (also valid, and what every professional expects)
public class Demo {
    public static void main(String[] args) {
        System.out.println("Hi");
    }
}

Indentation is not optional in practice. Use it every single time.

7. Errors

You are going to see error messages. A lot of them. Even experienced developers see error messages every single day. What matters is learning to read them and fix them quickly. There are three types of errors in Java.

Type 1: Syntax Errors (Compile-Time Errors)

A syntax error is a mistake in the structure of your code. Missing semicolon, misspelled keyword, unbalanced brace — these all cause syntax errors. Java catches them during compilation. Your program will not compile at all until they are fixed.

// WRONG - missing semicolon after println
public class Demo {
    public static void main(String[] args) {
        System.out.println("Hello")
    }
}
Demo.java:3: error: ';' expected
        System.out.println("Hello")
                                   ^
1 error

That error message tells you exactly what is wrong and exactly where. Line 3. Missing semicolon. Fix it there.

Type 2: Runtime Errors

A runtime error happens while the program is running, after it has compiled successfully. Your code is syntactically correct, but something goes wrong during execution. A classic example is dividing by zero or trying to use a null value.

public class Demo {
    public static void main(String[] args) {
        int x = 10;
        int y = 0;
        System.out.println(x / y);  // dividing by zero at runtime
    }
}
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Demo.main(Demo.java:5)

The program compiled fine. It crashed when it tried to execute line 5. The error message tells you which line, what went wrong, and what kind of exception it was.

Type 3: Logic Errors

A logic error is the sneakiest type. The program compiles and runs without crashing — but it produces the wrong result. Java cannot catch logic errors because the code is technically valid. You have to catch them by testing carefully.

public class Demo {
    public static void main(String[] args) {
        int total = 5 + 3;
        System.out.println("The answer is: " + total);
    }
}
The answer is: 8

If you wanted 5 * 3 but typed 5 + 3, the program runs fine and prints 8. Java has no way to know 8 was wrong — only you know the expected result. Logic errors are fixed through testing and debugging.

8. The Programming Process

Writing code is not just typing until it works. Professional programmers follow a process. Every step matters, and skipping steps leads to bugs that are painful to track down later.

The Five-Step Cycle

Step 1: Design
Before writing a single line of code, think about what your program needs to do. What inputs does it receive? What output should it produce? What steps will get you from input to output? Write it out in plain English or a simple diagram. This is called an algorithm — a step-by-step plan for solving a problem.

Step 2: Write
Translate your design into Java code. Focus on one piece at a time. Do not try to write everything at once. Write a small chunk, think about whether it matches your design, then continue.

Step 3: Compile
Run javac and see if your code compiles. Fix any syntax errors the compiler reports. If there are multiple errors, fix them from the top down — one early error can cause a cascade of fake errors below it.

Step 4: Test
Run your program and verify it does what you intended. Test with different inputs. Try edge cases — what happens with zero, negative numbers, empty input? Does the output match what you designed?

Step 5: Debug
If the output is wrong, you have a logic error. Read your code carefully. Add extra println statements to print intermediate values and see where things go off track. This is called debugging — the process of finding and fixing errors in a working program.

📋 Module Summary

Vocabulary Review

Knowledge Check

Answer each question below. Choose the single best answer for each.

public class Broken {
    public static void main(String[] args) {
        System.out.println("Hello")
    }
}

public class Calc {
    public static void main(String[] args) {
        int result = 10 + 5;   // should be 10 * 5
        System.out.println(result);
    }
}

✅ Answer Key