// Package declaration: Organizes code into namespaces (like folders on disk).
// Convention: reverse domain name (com.example) prevents collisions across organizations.
// If your company is "acme.com" and the project is "billing", use com.acme.billing.
package com.example;

// Import statements: Bring in code from other packages.
// Without this, you would have to write java.util.Date every single time.
// Wildcard imports (java.util.*) import everything -- convenient but can cause
// name collisions and makes it harder to see what a file actually depends on.
import java.util.Date;

// Class declaration: MUST match the filename (HelloWorld.java).
// One public class per file -- this is enforced by the compiler.
// Non-public classes can share a file, but in practice, one class per file
// is the universal convention in professional Java code.
public class HelloWorld {
    
    // Main method: The entry point. The JVM looks for exactly this signature.
    // Every keyword here is load-bearing:
    //   public  -- The JVM can call it from outside the class.
    //   static  -- It belongs to the class itself, not to an instance.
    //              The JVM does not create a HelloWorld object to call this.
    //   void    -- It returns nothing to the caller (exit codes use System.exit()).
    //   String[] args -- Command-line arguments passed when running the program.
    //                    e.g., "java HelloWorld foo bar" -> args = ["foo", "bar"]
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

int age = 25;                      // 32-bit signed integer, enough for most counting
long population = 8_000_000_000L;  // Underscores for readability -- compiler ignores them
                                   // The 'L' suffix is required; without it, the compiler
                                   // treats this as an int literal and overflows
double price = 19.99;              // 64-bit floating point, default for decimals
boolean isActive = true;           // Only two possible values: true or false
                                   // JVM implementation detail: booleans are stored as
                                   // int (0 or 1) internally -- there is no 1-bit type
char letter = 'A';                 // 16-bit Unicode character (UTF-16 code unit)
                                   // Single quotes for char, double quotes for String

String name = "Alice"; // 'name' is a reference on Stack -> Object on Heap
int[] numbers = {1, 2, 3}; // Arrays are objects too -- this lives on the Heap
Integer boxed = 42;    // Autoboxing: the compiler wraps the primitive int
                       // into an Integer object automatically.
                       // Useful because generics (List<Integer>) cannot use primitives.

// Autoboxing: int -> Integer (compiler inserts Integer.valueOf(5))
Integer wrapped = 5;

// Unboxing: Integer -> int (compiler inserts wrapped.intValue())
int unwrapped = wrapped;

// DANGER: unboxing null throws NullPointerException
Integer maybeNull = null;
int boom = maybeNull; // NullPointerException at runtime!

var message = "Hello";                // Inferred as String at compile time
var list = new ArrayList<String>();   // Inferred as ArrayList<String>
// var x;                             // COMPILE ERROR: cannot infer without initializer
// var nothing = null;                // COMPILE ERROR: cannot infer type from null

if (score >= 90) {
    System.out.println("A");
} else {
    System.out.println("B");
}

// Ternary Operator: Concise if-else
String status = (age >= 18) ? "Adult" : "Minor";

// Modern switch expression: returns a value, no break needed, no fall-through
String dayType = switch (day) {
    case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "Weekday";
    case SATURDAY, SUNDAY -> "Weekend";
    // If 'day' is an enum, the compiler checks exhaustiveness --
    // you get a compile error if you miss a case (no default needed).
    default -> throw new IllegalArgumentException("Invalid day: " + day);
};

String[] names = {"Alice", "Bob"};

for (String name : names) {
    System.out.println(name);
}

for (int i = 0; i < names.length; i++) {
    System.out.println(names[i]);
}

// Access Modifier | Return Type | Name | Parameters
public static int add(int a, int b) {
    return a + b;
    // 'static' means this method belongs to the class, not to an instance.
    // You call it as ClassName.add(1, 2), not object.add(1, 2).
}

void print(String s) { /* prints a string */ }
void print(int i)    { /* prints an integer */ }
void print(String s, int count) { /* prints string 'count' times */ }
// NOTE: Return type alone does NOT distinguish overloads.
// void print(int i) and int print(int i) cannot coexist -- compile error.

void printAll(String... items) {
    // 'items' is a String[] under the hood
    for (String item : items) {
        System.out.println(item);
    }
}

printAll("A", "B", "C"); // Valid: items = ["A", "B", "C"]
printAll();              // Valid: items = [] (empty array)
printAll(new String[]{"X", "Y"}); // Valid: you can also pass an explicit array

void tryToChange(int x, StringBuilder sb) {
    x = 999;             // Changes the local copy only -- caller's int is unaffected
    sb.append(" World"); // Mutates the SAME object the caller sees
    sb = new StringBuilder("New"); // Reassigns local copy only -- caller still
                                   // points at the original StringBuilder
}