// 1. ENCAPSULATION — bundling data + methods, hiding internals
class BankAccount {
    private double balance; // hidden from outside
    
    public void deposit(double amount) {
        if (amount > 0) balance += amount;
    }
    public double getBalance() {
        return balance; // controlled access
    }
}

// 2. INHERITANCE — child class inherits from parent
class Animal {
    void eat() { System.out.println("eating"); }
}
class Dog extends Animal {
    void bark() { System.out.println("woof"); }
}
// Dog has both eat() and bark()

// 3. POLYMORPHISM — same method, different behavior
// Compile-time (overloading):
class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
}
// Runtime (overriding):
class Animal {
    void sound() { System.out.println("generic sound"); }
}
class Cat extends Animal {
    void sound() { System.out.println("meow"); }
}

// 4. ABSTRACTION — hiding complexity, showing essentials
abstract class Shape {
    abstract double area(); // what, not how
}
class Circle extends Shape {
    double radius;
    double area() { return Math.PI * radius * radius; }
}

Abstract Class                Interface
─────────────────────         ─────────────────────
Can have constructors         No constructors
Can have instance variables   Only constants (static final)
Can have concrete methods     Only abstract methods (pre-Java 8)
Single inheritance only       Multiple interfaces allowed
"extends" keyword             "implements" keyword
Partial abstraction           Full abstraction

// Since Java 8, interfaces can have:
// - default methods (with body)
// - static methods
// Since Java 9: private methods in interfaces

// When to use which:
// Abstract class → shared state + partial implementation
// Interface → contract/capability (Serializable, Comparable)

// Strings are immutable — once created, cannot be changed

String s1 = "Hello";
s1.concat(" World"); // creates NEW string, s1 unchanged
System.out.println(s1); // "Hello" (not "Hello World")

// To capture the change:
s1 = s1.concat(" World"); // s1 now points to new object

// WHY immutable?
// 1. String Pool — multiple references share same object
//    If mutable, changing one would affect all
// 2. Security — used in class loading, network connections
// 3. Thread safety — immutable = inherently thread-safe
// 4. Hashcode caching — String caches its hashcode
//    (used in HashMap keys)

String         → Immutable, thread-safe, slow for concatenation
StringBuilder  → Mutable, NOT thread-safe, fast
StringBuffer   → Mutable, thread-safe (synchronized), slower

// When to use:
// String → when value does not change
// StringBuilder → single-threaded string manipulation
// StringBuffer → multi-threaded string manipulation

// Performance example:
// String concatenation in a loop creates N objects
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i; // creates 1000 String objects!
}

// StringBuilder creates only 1 object
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i); // modifies same object
}
String result = sb.toString();

// String pool: special memory area in heap
// Stores one copy of each unique string literal

String s1 = "Hello";     // goes to pool
String s2 = "Hello";     // reuses from pool
String s3 = new String("Hello"); // new object in heap

s1 == s2;      // true (same reference in pool)
s1 == s3;      // false (different objects)
s1.equals(s3); // true (same content)

// Rule: ALWAYS use .equals() for String comparison
// == compares references (memory addresses)
// .equals() compares actual content

ArrayList                    LinkedList
─────────────────────        ─────────────────────
Dynamic array internally     Doubly linked list
Fast random access O(1)      Slow random access O(n)
Slow insert/delete O(n)      Fast insert/delete O(1)
Less memory overhead         More memory (node pointers)
Better for read-heavy        Better for write-heavy

// Use ArrayList when:
// - You access elements by index frequently
// - You mostly add to the end
// - Read operations >> write operations

// Use LinkedList when:
// - You insert/delete from middle frequently
// - You use it as a Queue or Deque
// - Order of insertion matters more than access speed

// In practice: ArrayList is used 95% of the time

// HashMap stores key-value pairs using hashing

// Internal structure:
// Array of buckets (Node[])
// Each bucket is a linked list (or tree if > 8 nodes)

// put(key, value) process:
// 1. Calculate hashCode() of key
// 2. Find bucket index: hash & (n-1)
// 3. If bucket empty → store directly
// 4. If bucket has entries → check equals()
//    - Same key → update value
//    - Different key → add to linked list (collision)

// get(key) process:
// 1. Calculate hashCode() → find bucket
// 2. Traverse bucket, use equals() to find exact key

// Java 8 improvement:
// If a bucket has > 8 entries, linked list → red-black tree
// This improves worst-case from O(n) to O(log n)

// Default capacity: 16, Load factor: 0.75
// Resizes (doubles) when 75% full

HashMap        → No order guaranteed, O(1) operations
LinkedHashMap  → Maintains insertion order, O(1) operations
TreeMap        → Sorted by key (natural/comparator), O(log n)

// HashSet vs LinkedHashSet vs TreeSet → same pattern
// HashSet uses HashMap internally (values are dummy)

// When to use:
// HashMap → default choice, fastest
// LinkedHashMap → need insertion order (LRU cache)
// TreeMap → need sorted keys (range queries)

Checked Exceptions (compile-time):
- Must be handled (try-catch) or declared (throws)
- IOException, SQLException, FileNotFoundException
- Compiler forces you to handle them

Unchecked Exceptions (runtime):
- Not required to handle
- NullPointerException, ArrayIndexOutOfBoundsException
- Extend RuntimeException

// Exception hierarchy:
// Throwable
//   ├── Error (OutOfMemoryError, StackOverflowError)
//   └── Exception
//         ├── Checked (IOException, SQLException)
//         └── RuntimeException (unchecked)
//               ├── NullPointerException
//               ├── ArrayIndexOutOfBoundsException
//               └── ArithmeticException

final:
- Variable → cannot be reassigned
- Method → cannot be overridden
- Class → cannot be extended (String is final)

finally:
- Block that ALWAYS executes after try-catch
- Used for cleanup (closing connections, files)
try {
    // risky code
} catch (Exception e) {
    // handle error
} finally {
    // ALWAYS runs (even if exception occurs)
    connection.close();
}

finalize():
- Method called by garbage collector before destroying object
- Deprecated since Java 9 — do not use
- Use try-with-resources instead

// Method 1: Extend Thread class
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running");
    }
}
new MyThread().start();

// Method 2: Implement Runnable interface
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable running");
    }
}
new Thread(new MyRunnable()).start();

// Runnable is preferred because:
// 1. Java allows only single inheritance
//    (extending Thread blocks extending other classes)
// 2. Runnable separates task from thread management
// 3. Can be used with ExecutorService (thread pools)