Introduction to Java: What It Is, How It Works, and Why Developers Love It

// This file demonstrates the most basic Java program possible.
// Every Java program starts with a class. The class name MUST match the filename.
// Here the file is called WhatIsJava.java, so the class is called WhatIsJava.

public class WhatIsJava {

    // main() is the entry point — the first method Java looks for when you run the program.
    // Think of it as the front door of your application.
    // 'public' means anyone can call it.
    // 'static' means Java doesn't need to create an object to use it (we'll cover this later).
    // 'void' means this method doesn't return any value when it's done.
    // 'String[] args' allows command-line arguments to be passed in — ignore this for now.
    public static void main(String[] args) {

        // System.out.println() is Java's way of printing a line of text to the console.
        // 'System' is a built-in class. 'out' is a stream that points to your screen.
        // 'println' means 'print line' — it prints the text AND moves to the next line.
        System.out.println("Java is running on: " + System.getProperty("os.name"));

        // The + operator here joins two strings together — this is called concatenation.
        // System.getProperty("os.name") fetches the name of your operating system at runtime.
        // This proves the JVM abstraction: same code, different output depending on your machine.
        System.out.println("Java version in use: " + System.getProperty("java.version"));

        System.out.println("Hello from Java — Write Once, Run Anywhere!");
    }
}

// STEP 1: This is your source code — the .java file you write
// Save this as: CompileAndRunDemo.java

// STEP 2: Compile it in your terminal with:
//   javac CompileAndRunDemo.java
// This produces: CompileAndRunDemo.class (bytecode)

// STEP 3: Run it with:
//   java CompileAndRunDemo
// The JVM reads the .class file and executes it.

public class CompileAndRunDemo {

    public static void main(String[] args) {

        // Let's demonstrate that the JVM knows exactly what environment it's in.
        // These system properties are resolved at RUNTIME by the JVM on the current machine.
        String operatingSystem = System.getProperty("os.name");      // e.g. "Windows 11"
        String jvmVendor       = System.getProperty("java.vendor");  // e.g. "Oracle Corporation"
        String javaHome        = System.getProperty("java.home");    // path to your JVM install

        System.out.println("=== JVM Environment Report ===");

        // String.format() lets you build a string with placeholders (%s = string slot)
        // It's cleaner than chaining lots of + operators when you have multiple values
        System.out.println(String.format("Operating System : %s", operatingSystem));
        System.out.println(String.format("JVM Vendor       : %s", jvmVendor));
        System.out.println(String.format("Java Home        : %s", javaHome));

        System.out.println("\nSame .class file. Different machine. Same result.");
        // \n is an escape character — it inserts a blank line before printing the next line.
    }
}

// A real-world style program that uses variables, arithmetic, and output.
// Goal: calculate a student's average score and print a summary report.

public class StudentGradeCalculator {

    public static void main(String[] args) {

        // --- VARIABLE DECLARATIONS ---
        // 'String' holds text (always wrapped in double quotes in Java)
        String studentName = "Maria Chen";

        // 'int' holds whole numbers (integers) — no decimal places
        int mathScore    = 88;
        int scienceScore = 92;
        int englishScore = 79;

        // 'double' holds decimal numbers (floating-point values)
        // We use double here because dividing integers can lose the decimal part
        double averageScore = (mathScore + scienceScore + englishScore) / 3.0;
        // Why 3.0 and not 3? If you divide by the integer 3, Java does integer division
        // and throws away the decimal. Using 3.0 forces decimal (floating-point) division.

        // 'boolean' holds only true or false — nothing else
        boolean hasPassed = averageScore >= 75.0;
        // The >= operator means 'greater than or equal to'
        // This expression evaluates to either true or false and stores it in hasPassed

        // --- OUTPUT ---
        System.out.println("==============================");
        System.out.println("  Student Grade Report");
        System.out.println("==============================");

        // Concatenating variables into output strings using the + operator
        System.out.println("Student  : " + studentName);
        System.out.println("Math     : " + mathScore);
        System.out.println("Science  : " + scienceScore);
        System.out.println("English  : " + englishScore);

        // Rounding averageScore to 2 decimal places using String.format()
        // "%.2f" means: format as a floating-point number with 2 decimal places
        System.out.println("Average  : " + String.format("%.2f", averageScore));

        // Printing a boolean — Java prints 'true' or 'false' as text automatically
        System.out.println("Passed   : " + hasPassed);

        // --- CONDITIONAL LOGIC ---
        // An if/else block runs different code depending on whether a condition is true
        if (hasPassed) {
            // This block only runs if hasPassed is true
            System.out.println("\nResult: PASS — Great work, " + studentName + "!");
        } else {
            // This block only runs if hasPassed is false
            System.out.println("\nResult: FAIL — Keep studying, " + studentName + ".");
        }
    }
}

// A complete tour of Java's most important primitive and reference data types.
// Every variable here has a descriptive name that makes its purpose obvious.

public class JavaDataTypesShowcase {

    public static void main(String[] args) {

        // ===== PRIMITIVE TYPES =====

        // int: whole numbers from -2,147,483,648 to 2,147,483,647
        int numberOfStudentsInClass = 32;

        // long: whole numbers too big for int (use L suffix to tell Java it's a long literal)
        long populationOfEarth = 8_100_000_000L;
        // Note the underscores in the number: Java allows _ as a visual separator in numeric literals.
        // 8_100_000_000 is much easier to read than 8100000000. It has zero effect on the value.

        // double: decimal numbers (64-bit floating point — high precision)
        double priceOfCoffeeInDollars = 4.75;

        // float: decimal numbers (32-bit — less precise, uses F suffix)
        // Use double unless memory is extremely tight. float is rarely needed.
        float gpuTemperatureInCelsius = 72.5F;

        // boolean: can ONLY be true or false — nothing else
        boolean isJavaFunToLearn = true;

        // char: a SINGLE character, wrapped in SINGLE quotes (not double quotes)
        char firstLetterOfAlphabet = 'A';
        // Internally, Java stores 'A' as the number 65 (Unicode value).
        // That's why you can do arithmetic on chars: 'A' + 1 gives 'B'.

        // byte: tiny integer from -128 to 127 — useful for raw binary data
        byte singleByteValue = 100;

        // short: integer from -32,768 to 32,767 — rarely used in modern Java
        short yearOfJavaRelease = 1995;

        // ===== REFERENCE TYPE =====

        // String: a sequence of characters. Starts with capital S — it's a class.
        // Text goes in DOUBLE quotes. Single quotes are for char only.
        String greetingMessage = "Welcome to Java programming!";

        // String has built-in methods you can call with the dot (.) operator
        int lengthOfGreeting = greetingMessage.length(); // counts characters in the string
        String uppercaseGreeting = greetingMessage.toUpperCase(); // returns a new all-caps string

        // ===== PRINTING EVERYTHING =====
        System.out.println("=== Primitive Types ===");
        System.out.println("int    numberOfStudentsInClass : " + numberOfStudentsInClass);
        System.out.println("long   populationOfEarth       : " + populationOfEarth);
        System.out.println("double priceOfCoffeeInDollars  : " + priceOfCoffeeInDollars);
        System.out.println("float  gpuTemperatureInCelsius : " + gpuTemperatureInCelsius);
        System.out.println("boolean isJavaFunToLearn       : " + isJavaFunToLearn);
        System.out.println("char   firstLetterOfAlphabet   : " + firstLetterOfAlphabet);
        System.out.println("byte   singleByteValue         : " + singleByteValue);
        System.out.println("short  yearOfJavaRelease       : " + yearOfJavaRelease);

        System.out.println("\n=== Reference Type: String ===");
        System.out.println("Original : " + greetingMessage);
        System.out.println("Length   : " + lengthOfGreeting + " characters");
        System.out.println("Uppercase: " + uppercaseGreeting);
    }
}