Java Keywords — All 67 Reserved Words Explained

public class BankAccount {
    // Accessible from anywhere
    public String accountHolder;
    
    public void deposit(double amount) {
        balance += amount; // Called from any class
    }
}

public class BankAccount {
    private double balance; // Hidden from outside
    private String pin;     // Only accessible inside BankAccount
    
    // Controlled access via public method
    public double getBalance() {
        return balance;
    }
    
    // Pin never exposed outside
    private boolean validatePin(String input) {
        return this.pin.equals(input);
    }
}

// Interface definition
interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

// Abstract parent class
abstract class Animal {
    String name;
    abstract void makeSound();
}

// Duck: extends Animal (single inheritance),
//       implements two interfaces (multiple)
class Duck extends Animal implements Flyable, Swimmable {
    @Override
    public void makeSound() { System.out.println("Quack!"); }
    
    @Override
    public void fly() { System.out.println("Duck flying..."); }
    
    @Override
    public void swim() { System.out.println("Duck swimming..."); }
}

public class Employee {
    private String name;
    private int age;
    private String department;
    
    // Constructor chaining with this()
    public Employee(String name) {
        this(name, 0, "Unassigned"); // Calls 3-arg constructor
    }
    
    public Employee(String name, int age, String department) {
        this.name = name;           // Disambiguate field vs param
        this.age = age;
        this.department = department;
    }
    
    // Method chaining (Builder pattern style)
    public Employee setDepartment(String dept) {
        this.department = dept;
        return this; // Return current object
    }
}

// ❌ Old way (pre-Java 16) — verbose
if (obj instanceof String) {
    String s = (String) obj; // Manual cast needed
    System.out.println(s.length());
}

// ✅ Java 16+ Pattern Matching — clean
if (obj instanceof String s) {
    System.out.println(s.length()); // s already cast!
}

// ✅ Java 21 Pattern Matching in switch
String result = switch (obj) {
    case Integer i -> "Integer: " + i;
    case String s  -> "String: " + s.toUpperCase();
    case null      -> "null value";
    default        -> "Unknown type";
};

// ❌ Classic switch (pre-Java 14) — fall-through trap
int day = 3;
String dayName;
switch (day) {
    case 1: dayName = "Monday"; break;    // Must break!
    case 2: dayName = "Tuesday"; break;
    case 3: dayName = "Wednesday"; break;
    default: dayName = "Unknown";
}

// ✅ Java 14+ Switch Expression — clean, no fall-through
String dayName = switch (day) {
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    case 3 -> "Wednesday";
    default -> "Unknown";
}; // Note the semicolon — it's an expression!

// ✅ Java 14+ yield — return value from block
String category = switch (day) {
    case 1, 2, 3, 4, 5 -> "Weekday";
    case 6, 7 -> {
        System.out.println("Weekend detected!");
        yield "Weekend"; // yield returns value from block
    }
    default -> throw new IllegalArgumentException("Invalid day");
};

// Labeled break — exits the OUTER loop
outerLoop:
for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
        if (i == 2 && j == 3) {
            break outerLoop; // Breaks completely out of i-loop
        }
        System.out.println(i + "," + j);
    }
}
// Without label: inner break only exits j-loop
// With label: breaks out of both loops entirely

public class FileProcessor {
    
    // 'throws' in signature = declares checked exceptions
    public void processFile(String path) throws IOException {
        
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(path));
            String line = reader.readLine();
            
            if (line == null) {
                // 'throw' = manually throw an exception
                throw new IllegalStateException("File is empty!");
            }
            
        } catch (FileNotFoundException e) {
            // Catch specific exception
            System.err.println("File not found: " + e.getMessage());
            throw e; // Re-throw after logging
            
        } catch (IOException e) {
            // Multi-catch: handle multiple types
            System.err.println("IO Error: " + e.getMessage());
            
        } finally {
            // Always runs — MUST close resources here
            if (reader != null) {
                try { reader.close(); } catch (IOException ignored) {}
            }
            System.out.println("Finally block executed.");
        }
    }
}

public class Counter {
    private int count = 0;
    
    // Synchronized method — locks on 'this' object
    public synchronized void increment() {
        count++; // Thread-safe: only one thread at a time
    }
    
    // Synchronized block — more granular control
    public void decrement() {
        // Do non-critical work here...
        synchronized (this) {
            count--; // Only this block is synchronized
        }
    }
    
    // Static synchronized — locks on Counter.class object
    public static synchronized void staticMethod() {
        // Class-level lock, not instance-level
    }
}

public class ServerStatus {
    // Without volatile: thread B might read stale cached value
    // With volatile: all threads always read from main memory
    private volatile boolean isRunning = true;
    
    // Thread A calls this to stop the server
    public void shutdown() {
        isRunning = false; // Immediately visible to Thread B
    }
    
    // Thread B runs this loop — needs latest value of isRunning
    public void run() {
        while (isRunning) { // Reads fresh value every iteration
            processRequest();
        }
    }
}

public class User implements Serializable {
    private String username;    // Will be serialized
    private transient String password; // NEVER serialized
    private transient int sessionToken; // Excluded from byte stream
    
    // After deserialization: username restored,
    //   password = null, sessionToken = 0
}

public class PrimitiveDemo {
    public static void main(String[] args) {
        // All 8 primitives
        byte  b = 100;
        short s = 30000;
        int   i = 2_000_000;   // Underscore for readability (Java 7+)
        long  l = 9_000_000_000L; // L suffix required for long literals
        float f = 3.14f;          // f suffix required for float
        double d = 3.141592653589793;
        char  c = 'A';            // Single quotes for char
        boolean flag = true;
        
        // Integer overflow — wraps around silently!
        int max = Integer.MAX_VALUE; // 2147483647
        int overflow = max + 1;      // -2147483648 (wraps!)
        
        // Always use BigDecimal for money
        BigDecimal price = new BigDecimal("99.99");
        BigDecimal tax   = new BigDecimal("0.18");
        BigDecimal total = price.multiply(tax.add(BigDecimal.ONE));
    }
}

// ✅ var — less redundancy, same type safety
var list = new ArrayList<String>();     // ArrayList<String>
var map  = new HashMap<String, Integer>(); // HashMap<String,Integer>
var name = "Tech Sustainify";           // String
var count = 42;                          // int

// var in for-each — very clean
for (var entry : map.entrySet()) {
    System.out.println(entry.getKey() + " = " + entry.getValue());
}

// ❌ var NOT allowed: fields, method params, return types
// var field = "hello";  // Compile error — fields can't use var
// public var getName() { return name; }  // Compile error

// ❌ var must be initialized — type can't be inferred from null
// var x = null;  // Compile error — ambiguous type

// ONE line replaces ~80 lines of traditional POJO code
public record Point(double x, double y) {}

// The compiler auto-generates:
// - private final double x, y;
// - Point(double x, double y) constructor
// - double x() and double y() accessors
// - equals(), hashCode(), toString()

// Usage
var p1 = new Point(3.0, 4.0);
var p2 = new Point(3.0, 4.0);
System.out.println(p1.x());          // 3.0
System.out.println(p1.equals(p2));   // true (value-based)
System.out.println(p1);              // Point[x=3.0, y=4.0]

// Records with compact constructor — add validation
public record Person(String name, int age) {
    Person { // Compact constructor
        if (age < 0) throw new IllegalArgumentException("Age negative");
        name = name.trim(); // Can transform fields
    }
}

// Sealed class: ONLY Circle, Rectangle, Triangle can extend Shape
public sealed class Shape permits Circle, Rectangle, Triangle {}

// Permitted subclasses must declare their 'sealedness'
public final class Circle extends Shape {       // final: no further extension
    double radius;
}

public sealed class Rectangle extends Shape    // sealed: further restricted
    permits Square {}

public non-sealed class Triangle extends Shape {} // open to extension

// The payoff: exhaustive pattern matching in switch
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;
    // No 'default' needed! Compiler knows all cases are covered.
};

// final reference ≠ immutable object!
final List<String> list = new ArrayList<>();

list.add("Java");   // ✅ Valid — modifying internal state
list.add("Python"); // ✅ Valid — list is NOT immutable

// list = new ArrayList<>(); // ❌ Compile error — can't reassign

// To make truly immutable: use List.of() or Collections.unmodifiableList()
final List<String> immutable = List.of("Java", "Python");
// immutable.add("C++"); // ❌ Runtime UnsupportedOperationException

// Thread-safe Singleton — uses: class, private, static, volatile,
//                         synchronized, final, new, return, null, if
public final class DatabasePool {
    
    // volatile: ensures visibility across threads
    // static: single instance at class level
    private static volatile DatabasePool instance = null;
    
    private final String url;
    private final int maxConnections;
    
    // private constructor — prevents direct instantiation
    private DatabasePool(String url, int maxConnections) {
        this.url = url;
        this.maxConnections = maxConnections;
    }
    
    // Double-checked locking — gold standard Singleton pattern
    public static DatabasePool getInstance() {
        if (instance == null) {              // First check (no lock)
            synchronized (DatabasePool.class) {
                if (instance == null) {      // Second check (with lock)
                    instance = new DatabasePool("jdbc:mysql://...", 10);
                }
            }
        }
        return instance;
    }
}

// Modern Java 17–21 features: record, sealed, permits, var, switch

// Sealed type hierarchy for payment processing
public sealed interface PaymentResult
    permits PaymentResult.Success, PaymentResult.Failure, PaymentResult.Pending {
    
    record Success(String transactionId, double amount) implements PaymentResult {}
    record Failure(String reason, int errorCode)         implements PaymentResult {}
    record Pending(String referenceId, long estimatedMs) implements PaymentResult {}
}

// Exhaustive pattern matching — no default needed!
public class PaymentHandler {
    public void handle(PaymentResult result) {
        var message = switch (result) {
            case PaymentResult.Success s  ->
                "✅ Paid ₹" + s.amount() + " | TXN: " + s.transactionId();
            case PaymentResult.Failure f  ->
                "❌ Failed: " + f.reason() + " (code: " + f.errorCode() + ")";
            case PaymentResult.Pending p  ->
                "⏳ Pending " + p.estimatedMs() + "ms | Ref: " + p.referenceId();
        };
        System.out.println(message);
    }
}