Java Keywords - Complete Reference

public class StaticExample {
    // Static variable - shared by all instances
    static int count = 0;
    
    // Instance variable - separate for each object
    int id;
    
    public StaticExample() {
        count++;  // Increment static counter
        id = count;  // Assign unique ID
    }
    
    // Static method - can be called without creating object
    public static void displayCount() {
        System.out.println("Total objects created: " + count);
    }
    
    // Instance method - requires object
    public void displayId() {
        System.out.println("My ID: " + id);
    }
    
    public static void main(String[] args) {
        // Call static method without object
        StaticExample.displayCount();
        
        // Create objects
        StaticExample obj1 = new StaticExample();
        StaticExample obj2 = new StaticExample();
        StaticExample obj3 = new StaticExample();
        
        // Call static method
        StaticExample.displayCount();  // Output: Total objects created: 3
        
        // Call instance methods
        obj1.displayId();  // Output: My ID: 1
        obj2.displayId();  // Output: My ID: 2
    }
}

public class FinalExample {
    // Final variable - cannot be changed (constant)
    final double PI = 3.14159;
    final int MAX_SPEED;  // Can be initialized in constructor
    
    // Final method - cannot be overridden
    public final void displayInfo() {
        System.out.println("This method cannot be overridden");
    }
    
    public FinalExample() {
        MAX_SPEED = 120;  // Initialize final variable in constructor
    }
    
    public double calculateArea(double radius) {
        // PI cannot be changed here
        return PI * radius * radius;
    }
}

// Final class - cannot be extended
final class SecurityManager {
    public void checkAccess() {
        System.out.println("Access checked");
    }
}

// This would cause compilation error:
// class ExtendedSecurityManager extends SecurityManager { }

public class SynchronizedExample {
    private int counter = 0;
    
    // Synchronized method - only one thread can execute at a time
    public synchronized void increment() {
        counter++;
    }
    
    // Synchronized block - more fine-grained control
    public void incrementWithBlock() {
        // Non-critical code can run concurrently
        System.out.println("Processing...");
        
        // Only this block is synchronized
        synchronized(this) {
            counter++;
            System.out.println("Counter: " + counter);
        }
        
        // More non-critical code
        System.out.println("Done processing");
    }
    
    public int getCounter() {
        return counter;
    }
    
    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        
        // Multiple threads accessing synchronized methods
        Thread t1 = new Thread(() -> {
            for(int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        
        Thread t2 = new Thread(() -> {
            for(int i = 0; i < 1000; i++) {
                example.incrementWithBlock();
            }
        });
        
        t1.start();
        t2.start();
        
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Final counter value: " + example.getCounter());
    }
}