1.1 Step-by-Step Theory

1. You write source code in .java files. These files contain classes, methods, and statements.
2. The javac compiler produces bytecode. Bytecode is stored in .class files.
3. The JVM executes bytecode. This abstraction layer is why Java is portable across operating systems.
4. The JDK includes tools for development. The JRE/runtime alone is not enough when you need to compile or inspect programs.

1.2 Compile and Run Example

javac Hello.java
java Hello

2.1 Code and Output

public class Basics {
    public static void main(String[] args) {
        int age = 24;
        double score = 91.5;
        boolean passed = score >= 40;
        System.out.println(age + " " + score + " " + passed);
    }
}

2.2 Comparison

Java's static typing improves IDE support, refactoring safety, and compile-time detection of mistakes. The tradeoff is that you must define intent more explicitly up front.

3.1 Example

int[] scores = {35, 72, 88, 41};
int passed = 0;
for (int score : scores) {
    if (score >= 40) {
        passed++;
    }
}
System.out.println("Passed: " + passed);

3.2 Design Comparison

4.1 Method Example

public static int total(int[] values) {
    int sum = 0;
    for (int value : values) {
        sum += value;
    }
    return sum;
}

System.out.println(total(new int[]{10, 20, 30}));

4.2 Comparison Table

Java Strings are immutable, which improves safety but also means repeated concatenation can create many temporary objects. That is why StringBuilder exists for heavier assembly work.

5.1 Class Example

class Student {
    String name;
    int marks;

    Student(String name, int marks) {
        this.name = name;
        this.marks = marks;
    }

    boolean hasPassed() {
        return marks >= 40;
    }
}

5.2 Modeling Insight

6.1 Polymorphism Example

interface Notifier {
    void send(String message);
}

class EmailNotifier implements Notifier {
    public void send(String message) {
        System.out.println("Email: " + message);
    }
}

6.2 Comparison

7.1 Exception Example

try {
    int result = 10 / 0;
    System.out.println(result);
} catch (ArithmeticException ex) {
    System.out.println("Invalid arithmetic operation");
}

7.2 Collections Snapshot

One common beginner mistake is catching overly broad exceptions too early. Another is choosing data structures without thinking about uniqueness, ordering, or lookup behavior.

8.1 Generic and Lambda Example

List names = Arrays.asList("Asha", "Bala", "Irfan");
long count = names.stream()
    .filter(name -> name.length() > 4)
    .count();
System.out.println(count);

8.2 Comparison

9.1 I/O Example

try (BufferedWriter writer = Files.newBufferedWriter(Path.of("report.txt"))) {
    writer.write("Java course completed");
}
String value = Files.readString(Path.of("report.txt"));
System.out.println(value);

9.2 Deep Insight

Try-with-resources is important because file handling is not only about reading and writing correctly. It is also about reliably releasing OS resources even when failures occur halfway through the operation.

10.1 Runnable Example

Runnable task = () -> System.out.println("Running in: " + Thread.currentThread().getName());
Thread worker = new Thread(task);
worker.start();

10.2 Concurrency Risks

11.1 Ecosystem Snapshot

11.2 Why This Matters

Strong Java developers think beyond the source file. They understand how code is built, tested, packaged, and monitored. That broader perspective is one reason Java remains dominant in large, long-lived systems.