What is Java Programming? A Simple Explanation for 2026

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

# Save the file as HelloWorld.java

# 1. Compile source to bytecode
javac HelloWorld.java
# → creates HelloWorld.class

# 2. Run on the JVM
java HelloWorld
# → Hello, World!

public class HelloWorld {              // 1. class declaration
    public static void main(String[] args) {  // 2. entry point
        System.out.println("Hello, World!");  // 3. print to console
    }
}

// public  → accessible by the JVM
// static  → callable without creating an object
// void    → returns nothing
// main    → the method the JVM looks for
// String[] args → command-line arguments

HelloWorld.java   (source code you write)
        │
        │  javac
        ▼
HelloWorld.class  (bytecode — platform independent)
        │
        │  java
        ▼
      JVM         (interprets / JIT-compiles bytecode)
        │
        ▼
   Hello, World!  (output on your screen)

JVM Architecture (simplified):
┌─────────────────────────────────┐
│  Class Loader Subsystem         │
├─────────────────────────────────┤
│  Runtime Data Areas             │
│  - Method Area                  │
│  - Heap                         │
│  - Stack                        │
│  - PC Register                  │
│  - Native Method Stack          │
├─────────────────────────────────┤
│  Execution Engine               │
│  - Interpreter                  │
│  - JIT Compiler                 │
│  - Garbage Collector            │
└─────────────────────────────────┘

class Animal {
    void sound() { System.out.println("Some sound"); }
}
class Dog extends Animal {
    @Override
    void sound() { System.out.println("Woof"); }
}
public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();  // polymorphism
        a.sound();             // Woof
    }
}

public static void main(String[] args) {
//  ^      ^        ^      ^
//  |      |        |      └── command-line arguments
//  |      |        └───────── method name (JVM entry point)
//  |      └────────────────── static: callable without an object
//  └───────────────────────── public: accessible by the JVM
}

// 1. Java is case-sensitive
int Age = 25;   // 'Age' and 'age' are different variables

// 2. == vs .equals() for Strings
String a = "hi", b = "hi";
System.out.println(a == b);       // may be false (reference comparison)
System.out.println(a.equals(b));  // true  (value comparison)

// 3. Integer division truncates
System.out.println(5 / 2);        // 2, not 2.5
System.out.println(5 / 2.0);      // 2.5

public class Student {
    private String name;
    private int[] scores;

    public Student(String name, int[] scores) {
        this.name = name;
        this.scores = scores;
    }

    public double average() {
        int sum = 0;
        for (int s : scores) sum += s;
        return (double) sum / scores.length;
    }

    public String grade() {
        double avg = average();
        if (avg >= 90) return "A";
        if (avg >= 80) return "B";
        if (avg >= 70) return "C";
        return "F";
    }
}

public class GradeCalculator {
    public static void main(String[] args) {
        Student alice = new Student("Alice", new int[]{92, 88, 95});
        System.out.println(alice.name + " → " +
            alice.average() + " (" + alice.grade() + ")");
    }
}

Alice → 91.66666666666667 (A)

// average() = (92 + 88 + 95) / 3
//           = 275 / 3
//           = 91.67  (type-cast to double)

// grade()   = avg >= 90 → "A"