Java Ecosystem Fundamentals

Development vs. Runtime Environments

Understanding the distinction between JDK (Java Development Kit), JRE (Java Runtime Environment), and JVM (Java Virtual Machine) is critical.

• JDK: The comprehensive toolset containing libraries, development tools, and compilers required to build Java applications. It encompasses the JRE.
• JRE: The environment necessary solely for executing compiled .class files. It includes the JVM and core libraries.
• JVM: The abstract machine that executes bytecode. Its existence across different operating systems enables the "Write Once, Run Anywhere" philosophy by decoupling bytecode from specific platform implementations.

Core Language Structure

Data Handling and Scope

Variables are named memory locations storing data values. Primitive types (byte, short, int, long, float, double, boolean, char) store raw values on the stack, while reference types store pointers to objects located in the heap.

Access Control Modifiers

• private: Accessible only within the defining class.
• default (package-private): Accessible within the same package.
• protected: Accessible within the package and subclasses.
• public: Accessible from any class.

Type Casting and Conversion

Primitive types use value copying during assignment. Reference types copy the memory address, meaning multiple variables can point to the same object instance. When casting a parent class reference to a child class reference, explicit type casting is required if not done impilcitly.

---

Object-Oriented Principles

Inheritance and Polymorphism

Inheritance allows a subclass to acquire properties and behaviors from a superclass (single inheritance only). Polymorphism permits treating a subclass instance as a reference of its parent type. This requires method overriding.

• Overloading: Methods share names but differ in parameter lists (type or count).
• Overriding: Subclasses redefine methods defined in the parent. The signature must match exactly; return types must be compatible (covariant).

Key Keywords

• final: Prevents class extension, method overriding, or reassignment of variables/fields.
• static: Indicates membership at the class level rather than the instance level. Static blocks execute once during class loading.
• this: Refers to the current instance. this() calls other constructors within the same class and must be the first statement.
• super: Refers to the parent class instance. Used to call parent constructors or access overridden members.

---

Exception Management

Hierarchy

The hierarchy begins with Throwable. Error represents serious system failures (e.g., OOM), while Exception covers recoverable issues.

• Checked Exceptions: Must be declared or caught (e.g., IOException).
• Unchecked Exceptions: RuntimeExceptions and subclasses; do not require forced handling.

Handling Mechanisms

Exceptions are typically managed via try-catch-finally. The finally block executes regardless of success or failure, except if System.exit(0) is called. Using throw propagates errors, whereas throws declares potential exceptions in signatures.

---

Strings and Collections

String Immutability

Strings are immutable sequences of characters created via literals or new. Literals utilize the String Constant Pool, whereas new String() always creates a new heap object.

• StringBuilder: Mutable, non-thread-safe, higher performance.
• StringBuffer: Mutable, thread-safe, slower due to synchronization.

Collection Framework

Listss

• ArrayList: Backed by dynamic arrays. Fast random access, slower insertion/deletion requiring array shifts.
• LinkedList: Doubly-linked list. Optimal for frequent insertions/removals, slower search operations.

Sets

• HashSet: Unordered collection using HashMap internals. Ensures uniqueness based on hashCode() and equals().

Maps

• HashMap: Stores key-value pairs. Allows null keys/values. Not thread-safe.
• ConcurrentHashMap: Thread-safe alternative using segment locking strategies.
• TreeMap: Sorted map utilizing Red-Black tree structures.

---

Concurrency and Multithreading

Lifecycle States

Threads transition through states: New, Runnable, Running, Blocked, Waiting, and Terminated.

Synchronization

• volatile: Ensures visibility of changes across threads but does not guarantee atomicity.
• synchronized: Provides mutual exclusion. Lock levels include Biased, Lightweight, and Heavyweight depending on contention.
• Lock Interfaces: Offer more flexibility than synchronized blocks.

Thread Pools

Instead of manual lifecycle management, use executors:

1. FixedThreadPool: Fixed number of worker threads.
2. CachedThreadPool: Creates threads as needed, reuses idle ones.
3. ScheduledThreadPool: Handles delayed or periodic tasks.
4. SingleThreadExecutor: Sequential task execution in one thread.

Deadlocks

Deadlocks occur when threads wait indefinitely for resources held by each other. Prevention involves breaking circular wait conditions or enforcing resource ordering.

---

JVM Internals and Memory

Garbage Collection

The GC automatically reclaims memory occupied by unreachable objects. It operates on the Heap, specifically distinguishing between Eden space, Survivor spaces, and Old Generation.

Memory Models

• Stack: Stores local variables and partial results.
• Heap: Holds object instances and arrays.
• Method Area: Stores class structure, static fields, and constants.

---

Database Integration

JDBC Workflow

Standard flow involves loading drivers, establishing connections via DriverManager, preparing statements, executing SQL, and handling results before closing resources.

• Statement: Executes standard SQL commands.
• PreparedStatement: Pre-compiles queries, preventing injection attacks and improving performance via parameter placeholders.

Transactions and ACID

Transactions ensure atomicity, consistency, isolation, and durability.

• Isolation Levels: READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE.
• Anomalies: Dirty Read (reading uncommitted data), Non-repeatable Read, Phantom Read.

Indexes and Optimization

Indexes speed up lookups but consume disk space and slow down writes. Types include B-Trees and Hash indexes. Primary keys enforce uniqueness; unique keys allow nulls depending on schema configuration.

---

Web Technologies and Frameworks

Servlet API

Servlets handle client requests asynchronously. Key phases include initialization (init), service handling (service), and cleanup (destroy). They are singleton instances per context and generally not thread-safe without synchronization.

MVC Architecture

Separation of concerns divides logic into Model, View, and Controller.

• SpringMVC: Uses a DispatcherServlet to route requests to Controllers, which invoke Services (Models) and return Views.

Spring Framework

Core pillars include IoC (Inversion of Control) for dependency management and AOP (Aspect Oriented Programming) for modularizing cross-cutting concerns like logging or transactions.

• Annotations: @Component, @Autowired, @Configuration, @Service define bean lifecycles and relationships.
• Dependency Injection: Objects receive their dependencies externally rather than creating them internally.

Microservices and Boot

• Spring Boot: Simplifies configuration via auto-configurations and embedded servers.
• Spring Cloud: Enables distributed system patterns including service discovery, gateways, and load balancing.

Caching Strategies

To optimize performance, caching reduces database loads. Challenges include:

• Cache Penetration: Querying nonexistent data repeatedly.
• Cache Breakdown: Hot keys expiring under high concurrency.
• Cache Avalanche: Mass cache expiration causing DB spikes. Solutions involve sentinel checks, mutex locks, and staggered TTL settings.