Advanced

import java.util.concurrent.*;
import java.util.*;

// ConcurrentHashMap - thread-safe without blocking entire map
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>(); // => Empty map, uses lock striping for segments

// putIfAbsent - atomic operation
Integer result1 = map.putIfAbsent("key1", 100);
                                 // => Checks if key1 exists atomically
                                 // => Key doesn't exist, inserts key1=100
                                 // => Returns null (previous value was null/absent)
System.out.println(map.get("key1")); // => 100 (key1 now maps to 100)
Integer existing = map.putIfAbsent("key1", 200);
                                 // => Checks if key1 exists atomically
                                 // => Key exists with value 100, does NOT replace
                                 // => Returns 100 (existing value, map unchanged)
System.out.println(map.get("key1")); // => 100 (unchanged, still 100)

// computeIfAbsent - compute value if absent
Integer computed = map.computeIfAbsent("key2", k -> k.length() * 10);
                                 // => Checks if key2 exists, it doesn't
                                 // => Calls lambda with key: k="key2"
                                 // => Computes "key2".length() = 4, then * 10 = 40
                                 // => Inserts key2=40 atomically
                                 // => Returns computed value 40
System.out.println(map.get("key2")); // => 40 (key2 now maps to 40)
Integer recompute = map.computeIfAbsent("key2", k -> k.length() * 20);
                                 // => Checks if key2 exists, it does (value is 40)
                                 // => Lambda NOT called (optimization, key present)
                                 // => Returns existing value 40 (map unchanged)

// merge - combine values atomically
map.put("count", 1);                 // => Inserts count=1 into map
Integer merged = map.merge("count", 5, (old, val) -> old + val);
                                 // => Retrieves existing value: old=1
                                 // => Calls lambda with old=1, val=5 (merge value)
                                 // => Computes 1 + 5 = 6
                                 // => Updates count=6 atomically
                                 // => Returns merged result 6
System.out.println(map.get("count")); // => 6 (count now holds 6)

// CopyOnWriteArrayList - thread-safe list, copy-on-write semantics
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>(); // => Empty list, writes create new array copy
list.add("A"); // => Creates new internal array with ["A"]
list.add("B"); // => Creates new internal array with ["A", "B"]
System.out.println(list.size()); // => 2

// Safe iteration even if list modified during iteration
for (String s : list) { // => Iterator uses snapshot of list at iteration start
    System.out.println(s); // => Prints "A", then "B" (original snapshot)
    list.add("C"); // => Safe - iterator uses snapshot, won't see "C" in this loop
} // => Loop completes with 2 iterations (A, B), not affected by concurrent adds
System.out.println(list.size()); // => 4 (A, B, C, C - two "C"s added during loop)

// ConcurrentLinkedQueue - non-blocking FIFO queue (lock-free)
ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>(); // => Empty queue, uses CAS operations
boolean offered1 = queue.offer("First"); // => true (element added to tail)
boolean offered2 = queue.offer("Second"); // => true (element added after "First")
System.out.println(queue.size()); // => 2 (weakly consistent size, may be stale in concurrent env)
String head = queue.poll(); // => "First" (removed from head, queue now has ["Second"])
String head2 = queue.poll(); // => "Second" (removed from head, queue now empty)
String head3 = queue.poll(); // => null (queue empty)

// BlockingQueue - producer-consumer pattern with blocking
BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(10); // => Bounded queue, capacity 10

// Producer thread
Thread producer = new Thread(() -> { // => Creates producer thread (not started yet)
    try {
        for (int i = 0; i < 5; i++) { // => Will produce items 0-4
            blockingQueue.put(i); // => Blocks if queue full (capacity 10), waits until space available
            System.out.println("Produced: " + i); // => Output: "Produced: 0", "Produced: 1", etc.
            Thread.sleep(100); // => Simulate production work (100ms delay)
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt(); // => Restore interrupted status
    }
}); // => Thread created but not running

// Consumer thread
Thread consumer = new Thread(() -> { // => Creates consumer thread (not started yet)
    try {
        for (int i = 0; i < 5; i++) { // => Will consume 5 items
            Integer item = blockingQueue.take(); // => Blocks if queue empty, waits until item available
            System.out.println("Consumed: " + item); // => Output: "Consumed: 0", "Consumed: 1", etc.
            Thread.sleep(150); // => Simulate consumption work (150ms delay, slower than producer)
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt(); // => Restore interrupted status
    }
}); // => Thread created but not running

producer.start(); // => Start producer thread, begins producing items
consumer.start(); // => Start consumer thread, begins consuming items
// => Both threads run concurrently, queue coordinates between them
// => Output order may vary due to concurrent execution

import java.util.concurrent.atomic.*;

// AtomicInteger - thread-safe integer operations without locks
AtomicInteger counter = new AtomicInteger(0); // => Initialized to 0, uses CAS internally

// Atomic read and write operations
int current = counter.get(); // => 0 (volatile read, guaranteed visibility across threads)
counter.set(10); // => Set to 10 (volatile write, visible to all threads)
System.out.println(counter.get()); // => 10

// Atomic increment operations
int previous = counter.getAndIncrement(); // => 10 (returns old value, then increments to 11)
System.out.println(counter.get()); // => 11 (counter now 11)
int newValue = counter.incrementAndGet(); // => 12 (increments first, then returns new value)
System.out.println(counter.get()); // => 12 (counter now 12)

// compareAndSet - atomic compare-and-swap (CAS operation)
boolean success = counter.compareAndSet(12, 20); // => true (current was 12, set to 20 atomically)
System.out.println(counter.get()); // => 20 (successfully updated)
boolean failure = counter.compareAndSet(12, 30); // => false (current is 20, not 12, no update)
System.out.println(counter.get()); // => 20 (unchanged, CAS failed)

// updateAndGet - atomic update with lambda function
int updated = counter.updateAndGet(v -> v * 2);
                                 // => Reads current value: v=20
                                 // => Applies lambda: 20 * 2 = 40
                                 // => Atomically sets counter to 40 using CAS
                                 // => Returns new value 40
System.out.println(counter.get()); // => 40 (counter now 40)
// => Internally uses CAS loop: read, apply function, compareAndSet, retry if failed
// => Retries if another thread modified counter between read and update

// accumulateAndGet - atomic accumulation with binary operator
int accumulated = counter.accumulateAndGet(5, (curr, update) -> curr + update);
                                 // => Reads current value: curr=40
                                 // => Calls lambda with curr=40, update=5
                                 // => Computes 40 + 5 = 45
                                 // => Atomically sets counter to 45 using CAS
                                 // => Returns accumulated result 45
System.out.println(counter.get()); // => 45 (counter now 45)

// AtomicLong - for long values (same API as AtomicInteger)
AtomicLong longCounter = new AtomicLong(1000L); // => Initialized to 1000
long result = longCounter.addAndGet(500); // => 1500 (atomically adds 500, returns new value)
System.out.println(longCounter.get()); // => 1500

// AtomicBoolean - for thread-safe flags
AtomicBoolean flag = new AtomicBoolean(false); // => Initialized to false
boolean wasSet = flag.getAndSet(true); // => false (old value), flag now true
System.out.println(flag.get()); // => true (flag flipped atomically)
boolean swapped = flag.compareAndSet(true, false); // => true (was true, now false)
System.out.println(flag.get()); // => false (back to false)

// AtomicReference - for object references (any object type)
AtomicReference<String> ref = new AtomicReference<>("Hello"); // => Reference to "Hello"
boolean updated2 = ref.compareAndSet("Hello", "World"); // => true (swapped to "World")
String value = ref.get(); // => "World" (new reference)
ref.set("Java"); // => Reference now points to "Java"
System.out.println(ref.get()); // => "Java"

// Practical example: thread-safe counter without locks
AtomicInteger sharedCounter = new AtomicInteger(0); // => Shared between threads, starts at 0
Runnable task = () -> { // => Each thread runs this task
    for (int i = 0; i < 1000; i++) {
        sharedCounter.incrementAndGet(); // => Thread-safe atomic increment (CAS-based)
        // => No synchronized block needed, no lock contention
    }
}; // => Task increments counter 1000 times

Thread t1 = new Thread(task); // => First thread
Thread t2 = new Thread(task); // => Second thread
t1.start(); // => Start thread 1 (runs concurrently)
t2.start(); // => Start thread 2 (runs concurrently)
t1.join(); // => Wait for thread 1 to complete
t2.join(); // => Wait for thread 2 to complete
System.out.println("Final count: " + sharedCounter.get());
// => Output: "Final count: 2000" (always correct, 1000 + 1000)
// => With non-atomic int, result would be unpredictable (lost updates)

import java.util.concurrent.*;

// CountDownLatch - wait for multiple events
CountDownLatch latch = new CountDownLatch(3); // Wait for 3 events

// Worker threads count down
for (int i = 0; i < 3; i++) {
    int taskId = i;
    new Thread(() -> {
        System.out.println("Task " + taskId + " starting");
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        System.out.println("Task " + taskId + " done");
        latch.countDown(); // Decrement count
    }).start();
}

// Main thread waits for all tasks
latch.await(); // Blocks until count reaches 0
System.out.println("All tasks completed!"); // Prints after all 3 tasks done

// CyclicBarrier - synchronize threads at barrier
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("All threads reached barrier!"); // Barrier action
});

// Threads wait at barrier
for (int i = 0; i < 3; i++) {
    int threadId = i;
    new Thread(() -> {
        try {
            System.out.println("Thread " + threadId + " working");
            Thread.sleep(1000);
            System.out.println("Thread " + threadId + " waiting at barrier");
            barrier.await(); // Wait for all threads
            System.out.println("Thread " + threadId + " continues after barrier");
        } catch (Exception e) {}
    }).start();
}

// Barrier can be reused (cyclic)
// After all threads pass, barrier resets for next use

// Semaphore - control access to limited resources
Semaphore semaphore = new Semaphore(2); // Allow 2 concurrent accesses

Runnable task = () -> {
    try {
        semaphore.acquire(); // Acquire permit (blocks if none available)
        System.out.println(Thread.currentThread().getName() + " acquired permit");
        Thread.sleep(2000); // Simulate work
        System.out.println(Thread.currentThread().getName() + " releasing permit");
        semaphore.release(); // Release permit
    } catch (InterruptedException e) {}
};

// 5 threads compete for 2 permits
for (int i = 0; i < 5; i++) {
    new Thread(task, "Thread-" + i).start();
}

import java.util.concurrent.*;

// RecursiveTask - returns a result
class SumTask extends RecursiveTask<Long> {
    private final long[] array;
    private final int start, end;
    private static final int THRESHOLD = 1000;

    public SumTask(long[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        int length = end - start;

        // Base case: compute directly if small enough
        if (length <= THRESHOLD) {
            long sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        }

        // Recursive case: split into subtasks
        int mid = start + length / 2;
        SumTask leftTask = new SumTask(array, start, mid);
        SumTask rightTask = new SumTask(array, mid, end);

        leftTask.fork(); // Async execute left
        long rightResult = rightTask.compute(); // Compute right in current thread
        long leftResult = leftTask.join(); // Wait for left result

        return leftResult + rightResult;
    }
}

// Using ForkJoinPool
long[] numbers = new long[10000];
for (int i = 0; i < numbers.length; i++) {
    numbers[i] = i + 1;
}

ForkJoinPool pool = new ForkJoinPool(); // Default: Runtime.availableProcessors() threads
SumTask task = new SumTask(numbers, 0, numbers.length);
long result = pool.invoke(task); // => 50005000 (sum of 1 to 10000)

// RecursiveAction - no result (void)
class PrintTask extends RecursiveAction {
    private final int start, end;
    private static final int THRESHOLD = 10;

    public PrintTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected void compute() {
        if (end - start <= THRESHOLD) {
            for (int i = start; i < end; i++) {
                System.out.println("Processing: " + i);
            }
        } else {
            int mid = start + (end - start) / 2;
            PrintTask left = new PrintTask(start, mid);
            PrintTask right = new PrintTask(mid, end);
            invokeAll(left, right); // Fork both and wait for completion
        }
    }
}

PrintTask printTask = new PrintTask(0, 100);
pool.invoke(printTask); // Prints 0 to 99 in parallel

// Parallel streams use ForkJoinPool.commonPool()
long parallelSum = java.util.stream.LongStream.range(1, 10001)
    .parallel() // Uses ForkJoinPool internally
    .sum(); // => 50005000

import java.lang.annotation.*;
import java.lang.reflect.*;

// Custom annotation definition
@Retention(RetentionPolicy.RUNTIME) // => Annotation accessible at runtime via reflection
// => Without RUNTIME, annotation discarded after compilation (SOURCE/CLASS retention)
@Target(ElementType.METHOD) // => Restricts annotation to methods only
// => Other targets: TYPE (classes), FIELD, PARAMETER, CONSTRUCTOR, etc.
@interface Test {
    String description() default ""; // => Annotation parameter with default value
    // => Usage: @Test(description = "test name") or @Test() (uses default "")
    int timeout() default 0;
    // => Multiple parameters allowed in annotation
    // => Defaults make parameters optional
}

// Another annotation for classes
@Retention(RetentionPolicy.RUNTIME)
// => Class annotation also needs RUNTIME retention for reflection
@Target(ElementType.TYPE) // => Can only be applied to classes/interfaces
// => ElementType.TYPE includes classes, interfaces, enums, records
@interface Component {
    String value();
    // => No default = required parameter
    // => Must specify: @Component("ServiceName")
}

// Using custom annotations
@Component("UserService") // => Class-level annotation with value parameter
// => Accessible via clazz.getAnnotation(Component.class)
class UserService {
    @Test(description = "Verify user creation", timeout = 5000)
    // => Method-level annotation with both parameters specified
    // => timeout = 5000 milliseconds (5 seconds)
    public void testCreateUser() {
        System.out.println("Testing user creation");
        // => Prints: "Testing user creation" when invoked via reflection
    }

    @Test(description = "Verify user deletion")
    // => timeout parameter uses default value (0)
    // => Only description specified explicitly
    public void testDeleteUser() {
        System.out.println("Testing user deletion");
        // => Prints: "Testing user deletion" when invoked
    }

    public void helperMethod() {
        // No annotation
        // => Not detected by reflection scan for @Test
        // => Won't be invoked by test runner
    }
}

// Reflection - inspecting annotations at runtime
Class<?> clazz = UserService.class;
// => Gets Class object for UserService
// => Class<?> wildcard allows any class type

// Check if class has annotation
if (clazz.isAnnotationPresent(Component.class)) {
    // => Returns true if @Component annotation present on UserService class
    // => Returns false if annotation missing or not RUNTIME retention
    Component component = clazz.getAnnotation(Component.class);
    // => Retrieves @Component annotation instance
    // => Returns proxy object implementing Component interface
    System.out.println("Component name: " + component.value()); // => "UserService"
    // => Calls value() method on annotation proxy
    // => Prints: "Component name: UserService"
}

// Find all methods with @Test annotation
Method[] methods = clazz.getDeclaredMethods();
// => Gets ALL methods (public, private, protected, package-private)
// => Returns array of Method objects (reflection API)
// => getDeclaredMethods() excludes inherited methods
for (Method method : methods) {
    // => Iterates through all 3 methods: testCreateUser, testDeleteUser, helperMethod
    if (method.isAnnotationPresent(Test.class)) {
        // => Returns true for testCreateUser and testDeleteUser
        // => Returns false for helperMethod (no @Test annotation)
        Test test = method.getAnnotation(Test.class);
        // => Retrieves @Test annotation from method
        // => Returns proxy object with description() and timeout() methods
        System.out.println("Test: " + method.getName());
        // => Prints method name: "testCreateUser" or "testDeleteUser"
        System.out.println("  Description: " + test.description());
        // => Prints annotation parameter value
        // => "Verify user creation" or "Verify user deletion"
        System.out.println("  Timeout: " + test.timeout());
        // => Prints timeout value: 5000 or 0 (default)

        // Invoke method using reflection
        try {
            Object instance = clazz.getDeclaredConstructor().newInstance();
            // => Creates new UserService instance via no-arg constructor
            // => getDeclaredConstructor() finds constructor with matching params (none)
            // => newInstance() invokes constructor, returns new object
            method.invoke(instance); // Calls the test method
            // => Dynamically invokes method on instance
            // => Equivalent to: instance.testCreateUser() or instance.testDeleteUser()
            // => Prints: "Testing user creation" or "Testing user deletion"
        } catch (Exception e) {
            // => Catches: IllegalAccessException, InvocationTargetException, etc.
            // => Reflection throws checked exceptions
            e.printStackTrace();
            // => Prints stack trace if method invocation fails
        }
    }
}

// Reflection - inspecting class structure
Field[] fields = clazz.getDeclaredFields();
// => Gets all fields declared in UserService (none in this example)
// => Returns empty array for UserService (no fields)
for (Field field : fields) {
    // => Loop doesn't execute (UserService has no fields)
    System.out.println("Field: " + field.getName() + " (" + field.getType() + ")");
    // => Would print field name and type if fields existed
    // => Example output: "Field: counter (int)"
}

// Accessing private fields (be careful!)
class Person {
    private String name = "Alice";
    // => Private field normally inaccessible outside class
    // => Reflection can bypass access modifiers
}

Person person = new Person();
// => Creates Person instance with name = "Alice"
Field nameField = Person.class.getDeclaredField("name");
// => Gets Field object for "name" field
// => getDeclaredField("name") finds field by exact name
// => Throws NoSuchFieldException if field doesn't exist
nameField.setAccessible(true); // Bypass private access
// => Disables Java access control for this field
// => Allows reading/writing private field from outside class
// => Required to access private members via reflection
String name = (String) nameField.get(person); // => "Alice"
// => Reads field value from person instance
// => Returns Object, requires cast to String
// => Result: "Alice" (original value)
nameField.set(person, "Bob"); // Modify private field
// => Writes new value to field
// => Changes person.name from "Alice" to "Bob"
// => Bypasses immutability and encapsulation

// Built-in annotations
@Override // Compile-time check for method overriding
// => Compiler verifies method actually overrides superclass method
// => Compile error if method doesn't override anything
@Deprecated(since = "2.0") // Mark as deprecated
// => Warns users this class is deprecated
// => Compiler generates warnings when used
// => "since" parameter documents deprecation version
@SuppressWarnings("unchecked") // Suppress compiler warnings
// => Disables specific compiler warnings for this class
// => "unchecked" suppresses generic type safety warnings
class Example {
    @Override
    public String toString() { return "Example"; }
    // => Overrides Object.toString()
    // => @Override ensures this actually overrides (compile-time check)
    // => Returns: "Example"
}

// Basic enum
enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

Day today = Day.MONDAY;
System.out.println(today); // => MONDAY
System.out.println(today.ordinal()); // => 0 (position in enum)

// Enum with fields and methods
enum Planet {
    MERCURY(3.303e23, 2.4397e6),
    VENUS(4.869e24, 6.0518e6),
    EARTH(5.976e24, 6.37814e6),
    MARS(6.421e23, 3.3972e6);

    private final double mass; // kg
    private final double radius; // meters

    // Constructor (always private)
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    public double surfaceGravity() {
        final double G = 6.67300E-11;
        return G * mass / (radius * radius);
    }

    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

double earthWeight = 75.0; // kg
double marsWeight = Planet.MARS.surfaceWeight(earthWeight); // => ~28.4 kg

// Enum with abstract methods (constant-specific behavior)
enum Operation {
    PLUS {
        @Override
        public double apply(double x, double y) { return x + y; }
    },
    MINUS {
        @Override
        public double apply(double x, double y) { return x - y; }
    },
    TIMES {
        @Override
        public double apply(double x, double y) { return x * y; }
    },
    DIVIDE {
        @Override
        public double apply(double x, double y) { return x / y; }
    };

    public abstract double apply(double x, double y);
}

double result = Operation.PLUS.apply(5, 3); // => 8.0
double product = Operation.TIMES.apply(4, 7); // => 28.0

// Enum methods
Day[] days = Day.values(); // => [MONDAY, TUESDAY, ...]
Day day = Day.valueOf("FRIDAY"); // => FRIDAY

// Switch with enum (exhaustive in modern Java)
String typeOfDay = switch (today) {
    case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "Weekday";
    case SATURDAY, SUNDAY -> "Weekend";
};

// EnumSet - efficient set implementation for enums
import java.util.*;
EnumSet<Day> weekend = EnumSet.of(Day.SATURDAY, Day.SUNDAY);
EnumSet<Day> weekdays = EnumSet.range(Day.MONDAY, Day.FRIDAY);

// EnumMap - efficient map with enum keys
EnumMap<Day, String> schedule = new EnumMap<>(Day.class);
schedule.put(Day.MONDAY, "Team meeting");
schedule.put(Day.WEDNESDAY, "Code review");

// Sealed class - restricted inheritance hierarchy
sealed class Shape permits Circle, Rectangle, Triangle {
    // Only Circle, Rectangle, Triangle can extend Shape
}

// Permitted subclasses must be final, sealed, or non-sealed
final class Circle extends Shape {
    private final double radius;
    public Circle(double radius) { this.radius = radius; }
    public double area() { return Math.PI * radius * radius; }
}

final class Rectangle extends Shape {
    private final double width, height;
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    public double area() { return width * height; }
}

non-sealed class Triangle extends Shape {
    // non-sealed: allows further subclassing
    private final double base, height;
    public Triangle(double base, double height) {
        this.base = base;
        this.height = height;
    }
    public double area() { return 0.5 * base * height; }
}

// Pattern matching for instanceof (Java 16+)
Object obj = "Hello";
if (obj instanceof String s) {
    // s is automatically cast to String in this scope
    System.out.println(s.toUpperCase()); // => "HELLO"
}

// Pattern matching with sealed classes
Shape shape = new Circle(5.0);

// Switch pattern matching (Java 17+, enhanced in Java 21)
double area = switch (shape) {
    case Circle c -> Math.PI * c.radius * c.radius;
    case Rectangle r -> r.width * r.height;
    case Triangle t -> 0.5 * t.base * t.height;
    // Exhaustive: compiler knows all possible subtypes
};

// Pattern matching with guards (Java 21+)
String description = switch (shape) {
    case Circle c when c.radius > 10 -> "Large circle";
    case Circle c -> "Small circle";
    case Rectangle r when r.width == r.height -> "Square";
    case Rectangle r -> "Rectangle";
    case Triangle t -> "Triangle";
};

// Record patterns (Java 19+, finalized in Java 21)
record Point(int x, int y) {}

Object point = new Point(10, 20);
if (point instanceof Point(int x, int y)) {
    System.out.println("x: " + x + ", y: " + y); // => x: 10, y: 20
}

// Nested record patterns
record ColoredPoint(Point point, String color) {}

Object cp = new ColoredPoint(new Point(5, 10), "red");
if (cp instanceof ColoredPoint(Point(int x, int y), String color)) {
    System.out.println("Point at (" + x + ", " + y + ") is " + color);
    // => Point at (5, 10) is red
}

// Sealed interfaces
sealed interface Result permits Success, Failure {}
record Success(String data) implements Result {}
record Failure(String error) implements Result {}

Result result = new Success("Data loaded");
String message = switch (result) {
    case Success(String data) -> "Success: " + data;
    case Failure(String error) -> "Error: " + error;
};

// module-info.java in com.example.myapp module
module com.example.myapp {
    // Require other modules
    requires java.base; // Implicit, always available
    requires java.sql; // Explicit dependency on SQL module
    requires transitive java.logging; // Transitive: consumers get logging too

    // Export packages (make them accessible to other modules)
    exports com.example.myapp.api; // Public API
    exports com.example.myapp.internal to com.example.test; // Qualified export

    // Open packages for reflection (for frameworks like Spring, Hibernate)
    opens com.example.myapp.model; // Deep reflection allowed
    opens com.example.myapp.entity to org.hibernate.orm; // Qualified open

    // Provide service implementation
    provides com.example.myapp.api.Service
        with com.example.myapp.impl.ServiceImpl;

    // Use service
    uses com.example.myapp.api.Service;
}

// Without modules (pre-Java 9), all public classes are globally accessible
// With modules, only exported packages are accessible

// Checking module from code
Module module = String.class.getModule();
System.out.println(module.getName()); // => "java.base"
System.out.println(module.isNamed()); // => true

// Unnamed module (classpath code)
// Code on classpath runs in unnamed module, can access all modules

// Module layers and layers
ModuleLayer bootLayer = ModuleLayer.boot();
Set<Module> modules = bootLayer.modules();
modules.forEach(m -> System.out.println(m.getName()));

// Creating custom runtime images with jlink
// jlink --module-path $JAVA_HOME/jmods:mods --add-modules com.example.myapp --output customjre
// Creates minimal JRE with only required modules

// Module visibility example
// In com.example.myapp.api package (exported):
package com.example.myapp.api;
public class PublicService {
    // Accessible to other modules
}

// In com.example.myapp.internal package (not exported):
package com.example.myapp.internal;
public class InternalUtil {
    // NOT accessible to other modules, even though public
    // Stronger encapsulation than package-private
}

// Module benefits:
// 1. Reliable configuration: missing dependencies detected at startup
// 2. Strong encapsulation: internal packages truly internal
// 3. Scalable: module graph prevents accidental dependencies
// 4. Smaller deployments: jlink creates custom runtime images

// var for local variables (Java 10+)
var message = "Hello"; // Inferred as String
var count = 42; // Inferred as int
var price = 19.99; // Inferred as double

// Works with generics (reduces verbosity)
var list = new ArrayList<String>(); // Inferred as ArrayList<String>
var map = new HashMap<String, Integer>(); // HashMap<String, Integer>

// Diamond operator with var
var names = new ArrayList<>(); // Inferred as ArrayList<Object> (be careful!)
var scores = List.of(95, 87, 92); // Inferred as List<Integer>

// var in loops
var numbers = List.of(1, 2, 3, 4, 5);
for (var num : numbers) { // num inferred as Integer
    System.out.println(num);
}

for (var i = 0; i < 10; i++) { // i inferred as int
    System.out.println(i);
}

// var with streams
var stream = numbers.stream()
    .filter(n -> n > 2)
    .map(n -> n * 2); // Inferred as Stream<Integer>

// When var improves readability
var userRepository = new UserRepositoryImpl(); // Type obvious from right side
var configuration = ConfigurationLoader.load("config.json");

// When var reduces readability (avoid these)
var data = process(); // What type is data? Unclear!
var x = calculate(y); // What is x? Need to check calculate() return type

// var limitations
// Cannot use without initializer
// var x; // ERROR: cannot infer type

// Cannot use with null
// var name = null; // ERROR: cannot infer from null

// Cannot use for fields
class Example {
    // var field = "value"; // ERROR: var only for local variables
}

// Cannot use for method parameters
// void method(var param) {} // ERROR

// Cannot use for method return types
// var getValue() { return 42; } // ERROR

// var with method references
var comparator = Comparator.comparing(String::length); // Comparator<String>

// var doesn't change semantics, only reduces verbosity
var text = "Hello"; // Still statically typed as String
// text = 42; // ERROR: incompatible types

// Best practices
// ✅ Use var when type is obvious from right-hand side
var users = userService.getAllUsers();

// ✅ Use var for complex generic types
var result = new HashMap<String, List<Map<String, Object>>>();

// ❌ Avoid var when type isn't clear
var value = compute(); // What type? Check method signature

// ❌ Avoid var for primitives when literal type unclear
var flag = false; // Is it boolean or Boolean? Obvious here, but...
var number = 1; // int or Integer or long? Better: int number = 1;