Java Technical Interview Masterclass

// To inspect your active JVM architecture and runtime properties:
public class RuntimeInfo {
    public static void main(String[] args) {
        System.out.println("Java Version: " + System.getProperty("java.version"));
        System.out.println("JVM Vendor:   " + System.getProperty("java.vm.vendor"));
        System.out.println("JVM Name:     " + System.getProperty("java.vm.name"));
        System.out.println("Processors:   " + Runtime.getRuntime().availableProcessors());
        System.out.println("Max Memory:   " + (Runtime.getRuntime().maxMemory() / (1024 * 1024)) + " MB");
    }
}

// High-level source code
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

/* Disassembled bytecode via: javap -c Calculator
public int add(int, int);
  Code:
     0: iload_1         // Push local int variable 1 (a) onto operand stack
     1: iload_2         // Push local int variable 2 (b) onto operand stack
     2: iadd            // Pop both, add them, and push result
     3: ireturn         // Return integer from top of stack
*/

public class AppLauncher {
    // Valid standard entry point
    public static void main(String[] args) {
        System.out.println("Arguments received: " + args.length);
        for (String arg : args) {
            System.out.println("Arg: " + arg);
        }
    }

    // Also valid alternative syntax: varargs
    // public static void main(String... args)
}

/* 
JVM Architecture Visualization:
+-------------------------------------------------------------+
|                     ClassLoader Subsystem                   |
|   Loading (Bootstrap, Platform, App) -> Linking -> Init     |
+-------------------------------------------------------------+
|                     Runtime Data Areas                      |
| [ Metaspace (Metadata) ]     [ Shared Heap (Objects) ]      |
| [ Thread Stack ] [ PC Register ] [ Native Method Stack ]    |
+-------------------------------------------------------------+
|                      Execution Engine                       |
|   Interpreter | JIT Compiler (C1/C2) | Garbage Collector   |
+-------------------------------------------------------------+
|              Java Native Interface (JNI) & OS               |
+-------------------------------------------------------------+
*/

public class ClassLoaderInspection {
    public static void main(String[] args) {
        // Application ClassLoader
        ClassLoader appLoader = ClassLoaderInspection.class.getClassLoader();
        System.out.println("App Loader:      " + appLoader);

        // Platform ClassLoader
        ClassLoader platformLoader = appLoader.getParent();
        System.out.println("Platform Loader: " + platformLoader);

        // Bootstrap ClassLoader (represented as null in Java)
        ClassLoader bootstrapLoader = platformLoader.getParent();
        System.out.println("Bootstrap Loader: " + bootstrapLoader);
    }
}

// Escape Analysis Example:
public class PointEscape {
    static class Point { int x, y; Point(int x, int y){ this.x=x; this.y=y; } }

    public int calculateDistance() {
        // 'p' never escapes this method scope.
        // C2 Server compiler performs Scalar Replacement:
        // Allocates ints x and y in registers/stack; no Heap allocation or GC overhead!
        Point p = new Point(10, 20);
        return p.x + p.y;
    }
}

public class MemoryModelDemo {
    public static void main(String[] args) {
        int primitiveVar = 42;             // Stored on the Stack frame of main()
        Customer cust = new Customer("V"); // 'cust' reference is on Stack;
                                           // 'new Customer(...)' object instance is on Heap!
    }
}

class Customer {
    private String name; // Stored inside Customer object instance on Heap
    public Customer(String name) { this.name = name; }
}

public class ErrorScenarios {
    // 1. Causes StackOverflowError
    public static void infiniteRecursion() {
        infiniteRecursion();
    }

    // 2. Causes OutOfMemoryError: Java heap space
    public static void exhaustHeap() {
        java.util.List<byte[]> memoryHog = new java.util.ArrayList<>();
        while (true) {
            memoryHog.add(new byte[10 * 1024 * 1024]); // 10MB chunk
        }
    }
}

// JVM Flags to tune Metaspace:
// -XX:MetaspaceSize=128m       Initial allocation threshold before GC triggers
// -XX:MaxMetaspaceSize=512m    Upper limit preventing runaway native memory leaks

public class MetaspaceConcept {
    // Static fields live in Heap, not Metaspace!
    public static final String GLOBAL_FLAG = "ACTIVE"; 
}

public class GCRootsDemo {
    private static Object staticRoot = new Object(); // 1. GC Root (Class Static Ref)

    public void process() {
        Object localRoot = new Object();            // 2. GC Root (Thread Stack Ref)
        localRoot = null; // Object is now disconnected from GC Root and eligible for GC!
    }
}

public class SwitchExpressionsDemo {
    public enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }

    public static String getDayCategory(Day day) {
        // Switch as an expression returning a String
        return switch (day) {
            case MON, TUE, WED, THU, FRI -> "Weekday";
            case SAT, SUN -> {
                System.out.println("Weekend logging...");
                yield "Weekend"; // 'yield' yields value from block
            }
        }; // Exhaustive! No 'default' needed if all enum values covered
    }
}

// Complete, immutable data carrier in ONE line!
public record EmployeeRecord(int id, String name, double salary) {
    // Compact Constructor: No parameter list, no 'this.field = field' boilerplate
    public EmployeeRecord {
        if (salary < 0) {
            throw new IllegalArgumentException("Salary cannot be negative: " + salary);
        }
        name = name.trim(); // Normalized before assignment
    }
}

class RecordUsage {
    public static void main(String[] args) {
        EmployeeRecord emp = new EmployeeRecord(101, "  Alice  ", 95000);
        System.out.println(emp.name()); // Accessor method (not getName())
        System.out.println(emp);        // EmployeeRecord[id=101, name=Alice, salary=95000.0]
    }
}

public class TextBlocksDemo {
    public static void main(String[] args) {
        // Multi-line JSON without escaping quotes or string concatenation
        String jsonPayload = """
                {
                    "service": "orders",
                    "status": "APPROVED",
                    "code": 200
                }
                """;
        System.out.println(jsonPayload);
    }
}

public class PrimitivesVsRefs {
    public static void main(String[] args) {
        int a = 10;
        int b = a; // Value copied directly
        b = 20;
        System.out.println("a: " + a); // 10 (unaffected)

        int[] arr1 = {10};
        int[] arr2 = arr1; // Memory reference copied!
        arr2[0] = 99;
        System.out.println("arr1[0]: " + arr1[0]); // 99 (mutated via shared reference)
    }
}

import java.util.*;

public class VarInference {
    public static void main(String[] args) {
        // Reduces cumbersome repetitive declarations:
        var customerMap = new HashMap<String, List<String>>();
        // Equivalent to: Map<String, List<String>> customerMap = new HashMap<>();

        customerMap.put("VIP", List.of("Vinod", "Kayartaya"));
        for (var entry : customerMap.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }
    }
}

class Animal { void speak() { System.out.println("Animal sound"); } }
class Dog extends Animal { void speak() { System.out.println("Bark"); } }

public class TimePhases {
    public static void main(String[] args) {
        Animal a = new Dog();
        // At compile-time: compiler verifies that 'speak()' exists on Animal reference.
        // At runtime: JVM invokes Dog's speak() via dynamic method dispatch (vtable)!
        a.speak(); // Prints "Bark"
    }
}

# Compile source into 'bin' directory:
javac -d bin src/App.java

# Run with classpath:
java -cp bin App

# Inspect active GC activity every 1 second (1000ms):
jstat -gcutil 12345 1000

# Capture thread dump:
jstack 12345 > thread_dump.txt

// module-info.java
module co.vinod.orderprocessing {
    // Explicit dependencies
    requires java.sql;
    requires co.vinod.payment;

    // Exported packages (public API)
    exports co.vinod.orderprocessing.api;

    // Hidden internal implementation details
    // co.vinod.orderprocessing.internal is completely inaccessible outside!
}

public class EqualityDemo {
    public static void main(String[] args) {
        String s1 = new String("vinod");
        String s2 = new String("vinod");

        System.out.println(s1 == s2);      // false: Distinct heap allocations
        System.out.println(s1.equals(s2));  // true: Content equality
    }
}

interface Vehicle {
    void drive(); // Abstract

    // Default method: Backward-compatible extension
    default void stop() {
        System.out.println("Vehicle braking to a stop");
    }

    // Static utility method
    static boolean isValidSpeed(int speed) {
        return speed >= 0 && speed <= 300;
    }
}

class Car implements Vehicle {
    public void drive() { System.out.println("Car driving"); }
    // Inherits stop() automatically!
}

public class FinalDemo {
    private final int id; // Blank final
    private final java.util.List<String> items = new java.util.ArrayList<>();

    public FinalDemo(int id) {
        this.id = id; // Assigned in constructor
    }

    public void testMutation() {
        // items = new ArrayList<>(); // COMPILE ERROR: Cannot reassign final ref!
        items.add("Valid");           // ALLOWED: Internal object state is mutated!
    }
}

import java.io.*;

public class ExceptionTypes {
    // Checked: Compiler forces 'throws IOException' or try-catch
    public void readFile() throws IOException {
        FileReader fr = new FileReader("config.json");
    }

    // Unchecked: No compiler enforcement
    public int divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("Divider cannot be zero"); // RuntimeException
        }
        return a / b;
    }
}

// Sealed hierarchy
public sealed interface PaymentMethod permits CreditCard, UPI, NetBanking {}

public final class CreditCard implements PaymentMethod {}
public final class UPI implements PaymentMethod {}
public non-sealed class NetBanking implements PaymentMethod {} // Open for extension

class PaymentProcessor {
    public void process(PaymentMethod pm) {
        // Compiler knows exhaustive set of subtypes!
        if (pm instanceof CreditCard c) { /* process cc */ }
        else if (pm instanceof UPI u)   { /* process upi */ }
        else if (pm instanceof NetBanking n) { /* process net banking */ }
    }
}

public class NativeExample {
    // JNI legacy way:
    public native int getNativePid();

    static {
        System.loadLibrary("NativeUtils"); // Loads native .so or .dll
    }
}

/* 
Enterprise LTS Progression:
Java 8  (Core Functional & Streams)
  └── Java 11 (Modularization & Modern HTTP/2)
        └── Java 17 (Data Records, Sealed Types & Text Blocks)
              └── Java 21 (Virtual Threads & Concurrency)
*/