Java Fundamentals & JVM Execution Model

package com.accenture.ltt.codingstandards;

/**
 * Standard Production Class Demonstrating Java Naming Conventions:
 * - UpperCamelCase for Classes and Interfaces (PasswordValidator)
 * - lowerCamelCase for Methods and Variables (validatePassword, userPassword)
 * - UPPER_SNAKE_CASE for Constants (MIN_PASSWORD_LENGTH)
 */
public class PasswordValidator {

    // Constant: static final in UPPER_SNAKE_CASE
    private static final int MIN_PASSWORD_LENGTH = 8;

    /**
     * Validates if a password string meets length criteria.
     * @param password the password input to check
     * @return true if valid, false otherwise
     */
    public boolean validatePassword(String password) {
        // Always defend against NullPointerException
        if (password == null) {
            return false;
        }
        return password.length() >= MIN_PASSWORD_LENGTH;
    }

    public static void main(String[] args) {
        PasswordValidator validator = new PasswordValidator();
        
        // Read from command-line argument if provided, otherwise use fallback
        String testPassword = (args.length > 0) ? args[0] : "Secur3P@ssw0rd";
        
        boolean isValid = validator.validatePassword(testPassword);
        System.out.println("Password valid? " + isValid);
    }
}

package com.accenture.ltt;

public class DatatypeDemo {
    public static void main(String[] args) {
        int number = 25;             // 32-bit integer
        double price = 19.99;        // 64-bit IEEE 754 float
        char letter = 'A';           // 16-bit Unicode character
        boolean flag = true;         // 1-bit boolean flag

        // Widening Type Casting (Implicit conversion: int -> double, no precision loss)
        double widenedVal = number;

        // Narrowing Type Casting (Explicit cast: truncates decimal 19.99 to 19)
        int truncatedPrice = (int) price;

        // Autoboxing (Primitive int automatically wrapped in java.lang.Integer)
        Integer boxed = number;

        // Unboxing (Object unwrapped back to primitive)
        int unboxed = boxed;

        // Local Variable Type Inference (Java 10+ var keyword)
        var message = "Inferred as java.lang.String at compile time";

        System.out.println("Widened: " + widenedVal + " | Truncated: " + truncatedPrice);
        System.out.println("Boxed: " + boxed + " | Inferred: " + message);
    }
}

package com.accenture.ltt;

public class OperatorDemo {
    public static void main(String[] args) {
        int a = 10, b = 5;

        // Arithmetic operators
        System.out.println("Addition: " + (a + b));         // 15
        System.out.println("Multiplication: " + (a * b));   // 50

        // Relational operator
        System.out.println("Is a > b? " + (a > b));         // true

        // Short-circuit Logical AND (b < 10 is evaluated ONLY because a > 5 is true)
        System.out.println("Logical AND: " + (a > 5 && b < 10)); // true

        // Bitwise shift operators: Left shift (a << 1) multiplies by 2
        int shifted = a << 1; // 10 * 2 = 20
        System.out.println("10 << 1 = " + shifted);

        // Ternary conditional operator: (condition) ? if_true : if_false
        String status = (a >= 10) ? "Eligible" : "Ineligible";
        System.out.println("Status: " + status);
    }
}

package com.accenture.ltt;

public class LoopDemo {
    public static void main(String[] args) {
        // 1. Classic for loop: Used when exact iteration count is known
        for (int i = 1; i <= 3; i++) {
            System.out.println("For loop count: " + i);
        }

        // 2. While loop: Pre-tested condition (might execute 0 times if condition false)
        int j = 1;
        while (j <= 3) {
            System.out.println("While count: " + j);
            j++;
        }

        // 3. Do-While loop: Post-tested condition (GUARANTEED at least 1 execution)
        int k = 10;
        do {
            System.out.println("Do-While executes once even though 10 < 5 is false!");
        } while (k < 5);

        // 4. Labeled Break: Break completely out of NESTED outer loop directly
        searchBlock:
        for (int row = 0; row < 3; row++) {
            for (int col = 0; col < 3; col++) {
                if (row == 1 && col == 1) {
                    System.out.println("Target found at row 1, col 1! Breaking searchBlock...");
                    break searchBlock; // Exits BOTH loops immediately
                }
            }
        }
    }
}

package com.accenture.ltt.ui.tester.java17;

public class PatternSwitchDemo {
    public static void main(String[] args) {
        Object obj = "Java 17 LTS Backend";

        // Modern Java 17+ Pattern Matching Switch:
        // 1. No break statements needed (arrow syntax -> prevents fall-through bugs)
        // 2. Directly tests object type and binds cast variable (String s) in 1 step!
        // 3. Handles 'null' safely without NullPointerException
        String result = switch (obj) {
            case String s -> "String of length " + s.length() + ": " + s.toUpperCase();
            case Integer i -> "Integer multiplied: " + (i * 2);
            case null -> "Safe null handling";
            default -> "Other object type: " + obj.getClass().getSimpleName();
        };

        System.out.println(result);
    }
}

package com.accenture.ltt;

import java.util.Arrays;

public class ArrayDemo {

    // Varargs (int... numbers): Under the hood, the compiler creates an int[] array!
    public static int calculateSum(String label, int... numbers) {
        int total = 0;
        for (int n : numbers) {
            total += n;
        }
        System.out.println(label + ": " + total);
        return total;
    }

    public static void main(String[] args) {
        // 1. One-dimensional array
        int[] scores = { 85, 92, 78, 95, 88 };

        // Arrays utility class
        Arrays.sort(scores);
        System.out.println("Sorted scores: " + Arrays.toString(scores));

        // 2. Jagged (Ragged) Multidimensional Array
        int[][] jaggedMatrix = new int[3][];
        jaggedMatrix[0] = new int[] { 10, 20 };             // 2 elements
        jaggedMatrix[1] = new int[] { 30, 40, 50, 60 };     // 4 elements
        jaggedMatrix[2] = new int[] { 70 };                 // 1 element

        // 3. Varargs method call: Can pass 0, 1, or many arguments
        calculateSum("Department A Total", 100, 250, 400);
        calculateSum("Single Item", 50);
    }
}

public class MethodOverloadingAndRecursionDemo {

    // Method Overloading: Same method name, different parameter signatures
    public static int multiply(int a, int b) {
        return a * b;
    }

    public static double multiply(double a, double b) {
        return a * b;
    }

    public static int multiply(int a, int b, int c) {
        return a * b * c;
    }

    // Recursion: Method calling itself with a mandatory Base Case
    public static long factorial(int n) {
        // 1. BASE CASE: Stops infinite recursion and prevents StackOverflowError!
        if (n <= 1) {
            return 1;
        }
        // 2. RECURSIVE STEP: Method calls itself with smaller subproblem (n - 1)
        return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        // Compile-time polymorphism resolves the exact method from argument types:
        System.out.println("Overloaded int: " + multiply(5, 4));
        System.out.println("Overloaded double: " + multiply(2.5, 4.0));

        // Recursion: 5! = 5 * 4 * 3 * 2 * 1 = 120
        System.out.println("Factorial of 5: " + factorial(5));
    }
}