Java Interview Questions & Answers (2026)

The Birth of Java

Java was created by James Gosling along with Mike Sheridan and Patrick Naughton at Sun Microsystems (now owned by Oracle Corporation) in 1995. The language was originally called "Oak" after an oak tree that stood outside James Gosling's office. When the team discovered that Oak was already a trademark of Oak Technologies, the name was changed to Java, inspired by Java coffee that originated from the Indonesian island of Java.

Why Was Java Created?

In the early 1990s, software developers faced several major challenges that made building cross platform applications extremely difficult. The motivation behind creating Java was to solve these fundamental problems that plagued the industry at the time.

• Platform dependency meant that code written for Windows would not work on Mac or Unix without significant rewriting, forcing companies to maintain separate codebases for each operating system
• Memory management issues in languages like C and C++ required developers to manually allocate and deallocate memory, which frequently led to memory leaks and segmentation faults that were extremely hard to debug
• Pointer complexity in C and C++ caused crashes, buffer overflows, and critical security vulnerabilities that hackers could exploit to gain unauthorized access to systems
• No built in internet support meant that existing programming languages were not designed with networking and distributed computing in mind, making it cumbersome to build web connected applications
• Lack of portability forced development teams to recompile and often rewrite significant portions of their applications when targeting different processor architectures

The Green Project and Original Goal

Java was initially developed as part of the "Green Project" at Sun Microsystems. The project was started in June 1991 by James Gosling, Mike Sheridan, and Patrick Naughton. The original goal was to create a programming language for interactive television and embedded systems like set top boxes and other consumer electronics devices.

The team built a device called "*7" (Star Seven), which was a handheld home entertainment controller with an animated touchscreen user interface. This device demonstrated the potential of the new language. However, the digital cable television industry considered the technology too advanced for their needs at that time.

When the World Wide Web exploded in popularity during 1993 and 1994, Sun Microsystems recognized that Java's platform independent nature made it perfect for internet programming. They pivoted the language toward web development, and the rest is history. The first public implementation was Java 1.0 in 1996, and it delivered on the promise of "Write Once, Run Anywhere" with free runtimes on popular platforms.

Key Principles: Write Once, Run Anywhere (WORA)

Your First Java Program

To understand how Java works from the very beginning, here is the classic "Hello, World!" program that every Java developer starts with. This simple example demonstrates key Java concepts including class definition, the main method entry point, and console output.

In this example, public class HelloWorld defines a public class whose name must match the file name. The public static void main(String[] args) method is the entry point that the JVM calls when you run the program. System.out.println() prints a line of text to the standard output console.

Java's Evolution Timeline

Java has gone through numerous major releases since its inception, each one adding powerful features that have kept the language relevant and competitive. The following table summarizes the most important versions and their landmark features.

Java 8 Features: A Turning Point

Java 8 was arguably the most transformative release in Java's history. It introduced functional programming paradigms that fundamentally changed how Java developers write code. Here are some quick examples of the most important Java 8 additions.

Modern Java Features (Java 14 to 21)

Why Java Became Popular

Java's rise to becoming one of the most widely used programming languages in the world can be attributed to several key strengths that set it apart from competing languages during its early years and continue to make it relevant today.

• Platform Independence through the JVM allows true WORA capability, meaning the same compiled bytecode runs identically on Windows, macOS, Linux, and any other platform with a JVM implementation
• Object Oriented Design promotes clean, modular, and reusable code organization through encapsulation, inheritance, polymorphism, and abstraction
• Automatic Memory Management via garbage collection eliminates the burden of manual memory allocation and deallocation, preventing entire categories of bugs like memory leaks and dangling pointers
• Rich Standard Library provides an extensive API covering data structures, networking, file I/O, database connectivity, XML processing, and hundreds of other utilities out of the box
• Built in Security features including bytecode verification, the security manager, class loaders, and cryptography APIs make Java a trusted choice for enterprise and financial applications
• Native Multithreading Support allows developers to write concurrent programs that take full advantage of modern multi core processors
• Massive Developer Community with millions of developers worldwide, extensive documentation, thousands of open source libraries, and frameworks for virtually every use case
• Backward Compatibility ensures that code written decades ago still compiles and runs on modern JVM versions, protecting investments in existing codebases

Java in the Real World Today

Java remains one of the most popular programming languages in the world, consistently ranking in the top three on the TIOBE Index and Stack Overflow surveys. It powers critical systems across virtually every industry.

• Enterprise Applications in banking, insurance, and finance where reliability and security are paramount. Most major banks run their core systems on Java
• Android Mobile Applications as Android's official development language (alongside Kotlin), powering billions of devices worldwide
• Big Data Technologies including Apache Hadoop, Apache Spark, Apache Kafka, Apache Flink, and Elasticsearch are all written primarily in Java
• Cloud Native Applications running on AWS, Azure, and Google Cloud Platform with frameworks like Spring Boot, Quarkus, and Micronaut
• Microservices Architecture with Spring Cloud, Netflix OSS, and other Java based frameworks powering distributed systems at scale
• Internet of Things (IoT) devices and embedded systems leverage Java ME and the compact footprint of modern JVMs
• Scientific and Research Applications in fields like bioinformatics, physics simulation, and data analysis
• Gaming with Minecraft being one of the most popular games ever made, written entirely in Java

Understanding JDK, JRE, and JVM

Understanding the relationship between JDK, JRE, and JVM is fundamental to every Java developer and is one of the most frequently asked questions in Java interviews. These three components form a layered architecture where each layer builds upon the one below it.

The Java Ecosystem Hierarchy

JVM (Java Virtual Machine)

The JVM is an abstract computing machine that provides the runtime environment in which Java bytecode is executed. It is the cornerstone of Java's platform independence. The JVM itself is platform dependent (there are different JVM implementations for Windows, macOS, and Linux), but the bytecode it executes is platform independent. This is what makes the "Write Once, Run Anywhere" promise possible.

When you run a Java program, the JVM performs several critical tasks. It loads the compiled bytecode (.class files) into memory, verifies that the bytecode is valid and does not violate security constraints, and then executes the bytecode either through interpretation or just in time compilation to native machine code.

Core responsibilities of the JVM:

• Loading bytecode from .class files into memory through the Class Loader subsystem
• Verifying bytecode to ensure it conforms to the JVM specification and does not perform illegal operations
• Executing bytecode through the Execution Engine which combines an interpreter with a JIT compiler
• Providing the runtime environment including memory management, thread scheduling, and security enforcement
• Managing memory by dividing it into distinct areas (heap, stack, method area) and performing automatic garbage collection
• Handling exceptions and propagating them through the call stack

JVM Architecture in Detail

The JVM architecture can be divided into three major subsystems. The Class Loader Subsystem handles loading, linking, and initializing classes. The Runtime Data Areas provide the memory structures needed during execution. The Execution Engine performs the actual bytecode execution.

Class Loader Delegation Model

Java uses a parent delegation model for class loading. When a class needs to be loaded, the request is first delegated to the parent class loader before the child attempts to load it. This prevents core Java classes from being overridden by user defined classes with the same name.

JRE (Java Runtime Environment)

The JRE provides the complete environment needed to run Java applications. It bundles the JVM together with all the standard class libraries and supporting files that Java programs need at runtime. If you only need to run Java programs (not develop them), the JRE is all you need.

Components included in the JRE:

• JVM as the core execution engine
• Java Class Libraries including java.lang (fundamental classes), java.util (data structures and utilities), java.io (input/output), java.net (networking), java.sql (database access), and hundreds more
• Supporting files including property settings, resource files, fonts, and security configurations
• Deployment technologies including Java Web Start and Java Plugin (deprecated in later versions)

JDK (Java Development Kit)

The JDK is the full featured software development kit required for developing Java applications. It is a superset of the JRE, containing everything the JRE has plus additional tools needed for development, compilation, debugging, and documentation.

Development tools included in the JDK:

• javac is the Java compiler that converts .java source files into .class bytecode files
• java is the application launcher that starts the JVM and runs your program
• jdb is the Java debugger for stepping through code and inspecting variables
• javadoc generates HTML documentation from source code comments
• jar packages compiled classes and resources into JAR (Java Archive) files
• javap is the class file disassembler that shows bytecode instructions
• jconsole and jvisualvm are monitoring and profiling tools
• jshell (Java 9+) is the interactive REPL for quick experimentation
• jlink (Java 9+) creates custom runtime images with only the modules you need
• jpackage (Java 14+) creates platform specific installers for your application

JDK vs JRE vs JVM: Comparison Table

How Java Code Executes: Step by Step

Understanding the complete lifecycle of Java code execution from writing source code to seeing output on the screen is essential. Here is the detailed flow.

Viewing Bytecode with javap

You can use the javap tool included in the JDK to disassemble .class files and inspect the bytecode that the JVM actually executes. This is incredibly useful for understanding what happens under the hood.

JIT Compiler (Just In Time) Deep Dive

The JIT compiler is one of the most important performance optimizations in the JVM. Rather than interpreting bytecode every time a method is called, the JIT compiler identifies frequently executed code paths (called "hotspots") and compiles them directly into native machine code for the current platform.

• First execution: bytecode is interpreted line by line, which is slower but requires no compilation time
• Profiling: the JVM continuously monitors which methods are called frequently and how many times loops iterate
• Hotspot detection: when a method exceeds a configurable invocation threshold (typically 10,000 calls), the JVM marks it as a hotspot
• Compilation: the JIT compiler compiles the hotspot bytecode into optimized native machine code in the background
• Subsequent calls: all future invocations of that method use the compiled native code, which is significantly faster
• Deoptimization: if assumptions made during compilation become invalid (like a class being loaded that changes the type hierarchy), the JVM can deoptimize back to interpreted mode

JVM Tuning: Common JVM Flags

Understanding JVM flags is important for performance tuning in production environments and is a common topic in senior level interviews.

What is the Java Collections Framework?

The Java Collections Framework (JCF) is a unified architecture introduced in Java 1.2 for representing and manipulating groups of objects. It provides a set of interfaces, abstract classes, and concrete implementations that allow developers to store, retrieve, manipulate, and communicate aggregate data in a standardized way. The framework is found in the java.util package and is one of the most heavily used parts of the Java standard library.

Before the Collections Framework existed, Java developers had to use arrays, Vectors, and Hashtables, each with different APIs and no common interface. The framework solved this by introducing a consistent hierarchy of interfaces and classes.

Core Interfaces Hierarchy

List Interface: Ordered Collections

The List interface represents an ordered collection that allows duplicate elements and maintains insertion order. Elements can be accessed by their integer index position, similar to arrays but with dynamic sizing.

ArrayList: Dynamic Array Implementation

ArrayList is backed by a dynamically resizable array. When the internal array reaches capacity, it creates a new array that is 50% larger and copies all elements over. This makes ArrayList excellent for random access but slower for insertions and deletions in the middle.

ArrayList internal resizing behavior:

LinkedList: Doubly Linked List Implementation

LinkedList uses a doubly linked list data structure where each element (node) contains a reference to both the previous and next nodes. It implements both the List and Deque interfaces, making it versatile for stack, queue, and deque operations.

Set Interface: Unique Element Collections

The Set interface represents a collection that cannot contain duplicate elements. It models the mathematical set abstraction. When you add a duplicate element, the add method returns false and the set remains unchanged.

HashSet: Hash Table Implementation

HashSet stores elements in a hash table. It uses the element's hashCode() method to determine which bucket the element goes into and the equals() method to check for duplicates. This gives O(1) average time complexity for add, remove, and contains operations.

TreeSet: Sorted Set Implementation

TreeSet uses a Red Black tree data structure internally, which means all elements are stored in sorted (ascending) order. Every operation (add, remove, contains) has O(log n) time complexity. Elements must be Comparable or you must provide a Comparator.

Map Interface: Key Value Pairs

The Map interface represents a collection of key value pairs where each key is unique. It is not part of the Collection interface hierarchy but is a core part of the Collections Framework. Maps are essential for lookups, caching, counting, and grouping operations.

HashMap: The Workhorse

HashMap is the most commonly used Map implementation. It stores key value pairs in an array of buckets. The key's hashCode() determines the bucket, and equals() resolves collisions. Since Java 8, when a bucket has more than 8 entries, it converts from a linked list to a balanced tree for O(log n) worst case lookups instead of O(n).

HashMap Internal Working

Understanding how HashMap works internally is one of the most popular Java interview questions. Here is the detailed mechanism.

ConcurrentHashMap: Thread Safe Map

Queue and Deque Interfaces

The Queue interface is designed for holding elements prior to processing, typically in FIFO (First In, First Out) order. The Deque (Double Ended Queue) interface extends Queue and allows insertion and removal at both ends.

PriorityQueue

ArrayDeque: Stack and Queue Replacement

Collections Utility Class

The java.util.Collections utility class provides static methods for operating on collections, including sorting, searching, shuffling, and creating synchronized or unmodifiable wrappers.

Comparison Tables

ArrayList vs LinkedList

HashMap vs TreeMap vs LinkedHashMap

HashSet vs TreeSet vs LinkedHashSet

Java Memory Structure

Understanding how Java manages memory is critical for writing performant applications and for succeeding in Java interviews. The JVM divides memory into several distinct areas, each serving a specific purpose during program execution. Memory management in Java is largely automatic thanks to the garbage collector, but understanding the underlying mechanics helps developers write efficient code and debug memory related issues.

Memory Areas in JVM

Heap Memory Deep Dive

The heap is the largest area of JVM memory and is where all objects and their instance variables are stored. Every time you use the new keyword, the object is allocated on the heap. The heap is shared among all threads, which means any thread can access any object on the heap (provided it has a reference to it).

• Shared among all threads in the application
• Created at JVM startup and exists for the entire lifetime of the application
• Garbage collection operates exclusively on the heap to reclaim unreferenced objects
• Size controlled by JVM flags: -Xms sets the initial heap size and -Xmx sets the maximum heap size
• Throws OutOfMemoryError when the heap is full and the garbage collector cannot free enough space

Young Generation

The Young Generation is where all new objects are initially allocated. It is divided into three spaces: Eden and two Survivor spaces (S0 and S1). Most objects are short lived and die young, so the Young Generation is designed for fast allocation and collection.

• Eden Space is where brand new objects are allocated. When Eden fills up, a Minor GC is triggered
• Survivor Spaces (S0 and S1) hold objects that survived at least one garbage collection cycle. Objects are copied between S0 and S1 during each Minor GC
• Minor GC occurs frequently in the Young Generation and is typically very fast (milliseconds)
• Objects that survive enough GC cycles (configurable via -XX:MaxTenuringThreshold, default 15) are promoted to Old Generation

Old Generation (Tenured)

The Old Generation stores long lived objects that have survived multiple garbage collection cycles in the Young Generation. These are typically objects referenced throughout the application's lifetime such as cached data, singleton instances, and long running service objects.

• Major GC (or Full GC) occurs here and is significantly slower than Minor GC
• Full GC typically causes "stop the world" pauses where all application threads are halted
• Proper sizing of Young and Old generations is key to minimizing GC pauses

Metaspace (Java 8+)

Metaspace replaced the older PermGen (Permanent Generation) starting in Java 8. It stores class metadata, method data, and the runtime constant pool. Unlike PermGen, Metaspace uses native memory and can grow dynamically.

Stack Memory

The stack stores method call information and local variables. Each thread in Java gets its own private stack, which means stack data is inherently thread safe. The stack follows a LIFO (Last In, First Out) structure where each method call creates a new stack frame that is pushed onto the stack and popped off when the method returns.

• One stack per thread means stack memory is not shared between threads
• Stack frames are created for each method call and contain local variables, method parameters, and return addresses
• Primitive values (int, float, boolean, etc.) are stored directly in the stack frame
• Object references are stored in the stack, but the actual objects they point to are on the heap
• Automatically cleaned up when a method returns, its stack frame is popped and all local variables are destroyed
• Size controlled by the -Xss flag (default is typically 512KB or 1MB depending on platform)
• Throws StackOverflowError when the stack is full, typically caused by deep or infinite recursion

Heap vs Stack: Complete Comparison

Memory Allocation Example

Let us trace through a code example to understand exactly what goes on the stack versus the heap.

String Pool and Memory

The String Pool (also called the String Intern Pool) is a special area within the heap where Java stores literal string values. When you create a string using a literal, Java first checks the pool. If the same string already exists, it returns a reference to the existing object instead of creating a new one. This optimization saves significant memory in applications that use many strings.

Garbage Collection Deep Dive

Garbage Collection (GC) is the automatic process by which the JVM identifies and removes objects that are no longer reachable from any live reference in the application. This frees up heap memory for new object allocations. Unlike C and C++ where developers must manually free memory, Java's garbage collector handles this entirely behind the scenes.

How GC Determines Object Eligibility

The garbage collector uses a concept called reachability analysis. Starting from a set of "GC roots" (such as local variables, static fields, and active thread references), the collector traverses all object references. Any object that cannot be reached from any GC root is considered eligible for garbage collection.

GC Algorithms Comparison

Memory Leaks in Java

Contrary to popular belief, Java applications can absolutely have memory leaks. A memory leak in Java occurs when objects are no longer needed by the application but still have active references, preventing the garbage collector from reclaiming them. Over time this causes the heap to fill up and eventually results in an OutOfMemoryError.

Monitoring Memory with JVM Tools

Understanding Multithreading in Java

Multithreading is one of Java's most powerful features and one of the most commonly tested topics in Java interviews. It allows a program to execute multiple tasks simultaneously within a single process, making efficient use of modern multi core processors. Java was one of the first mainstream languages to provide built in support for multithreading at the language level.

What is a Thread?

A thread is the smallest unit of execution within a process. Every Java program starts with at least one thread called the "main" thread, which is created by the JVM when you call the main() method. From there, you can create additional threads to perform tasks concurrently.

Process vs Thread

Creating Threads in Java

Java provides multiple ways to create and manage threads. Each approach has its own advantages depending on the use case.

Method 1: Extending the Thread Class

Method 2: Implementing Runnable Interface (Preferred)

Method 3: Implementing Callable (Returns a Result)

Thread Lifecycle and States

Synchronization: Preventing Race Conditions

Synchronization is the mechanism that ensures only one thread can access a shared resource at a time. Without synchronization, multiple threads reading and writing shared data simultaneously can cause race conditions where the outcome depends on unpredictable thread scheduling.

The Race Condition Problem

Synchronized Methods

Synchronized Blocks (More Granular Control)

Inter Thread Communication

Threads often need to coordinate with each other. Java provides wait(), notify(), and notifyAll() methods on the Object class for inter thread communication. These methods must be called from within a synchronized context.

Deadlock: Causes and Prevention

Deadlock occurs when two or more threads are permanently blocked, each waiting for a lock held by the other. This creates a circular dependency that can never be resolved, effectively freezing the affected threads forever.

Four Conditions for Deadlock

All four of these conditions must be true simultaneously for a deadlock to occur. Breaking any one of them prevents deadlock.

1. Mutual Exclusion means a resource can only be held by one thread at a time
2. Hold and Wait means a thread holds one resource while waiting for another
3. No Preemption means a resource cannot be forcibly taken from a thread
4. Circular Wait means two or more threads form a circular chain of lock dependencies

Executor Framework and Thread Pools (Modern Approach)

The Executor Framework, introduced in Java 5, provides a higher level abstraction for managing threads. Instead of manually creating and managing Thread objects, you submit tasks to thread pools that handle the threading details for you. This is the recommended way to manage concurrency in modern Java applications.

CompletableFuture: Async Programming (Java 8+)

Virtual Threads (Java 21+, Project Loom)

Virtual Threads are a groundbreaking addition in Java 21 that allow creating millions of lightweight threads with minimal overhead. Traditional platform threads map 1:1 to OS threads (expensive, limited to thousands). Virtual threads are managed by the JVM and are mounted on platform threads only when executing CPU work.

Volatile Keyword

The volatile keyword ensures that a variable's value is always read from and written to main memory, preventing threads from caching stale values in their local CPU cache.

Exception Handling in Java

Exception handling is a robust mechanism in Java for dealing with runtime errors and exceptional conditions that disrupt the normal flow of program execution. Rather than letting errors crash your application, Java provides structured ways to catch, handle, and recover from these situations gracefully. Proper exception handling is one of the hallmarks of production quality Java code and is extensively tested in interviews.

What is an Exception?

An exception is an event that occurs during program execution that disrupts the normal instruction flow. When an exception occurs, Java creates an exception object containing information about the error (type, message, stack trace) and hands it to the runtime system. This process is called "throwing" an exception.

Complete Exception Hierarchy

Checked vs Unchecked Exceptions

Try Catch Finally: Complete Syntax

Try With Resources (Java 7+): Automatic Resource Management

The try with resources statement ensures that each resource is closed at the end of the statement, even if an exception occurs. This is the preferred way to handle any object that implements the AutoCloseable interface.

Throw vs Throws

throw: Explicitly Throwing an Exception

throws: Declaring Exceptions in Method Signature

Custom Exceptions

Creating custom exceptions allows you to define domain specific error types that provide meaningful context about what went wrong in your application. This is a best practice in production code.

Multi Catch Block (Java 7+)

Common Exceptions with Code Examples

Exception Propagation

When an exception is thrown, the JVM searches for a matching catch block in the current method. If none is found, the exception propagates up the call stack to the calling method. This continues until a matching handler is found or the exception reaches the main method, at which point the JVM prints the stack trace and terminates the program.

Exception Handling Best Practices

• Catch specific exceptions rather than generic Exception or Throwable. This ensures you handle each error type appropriately
• Never swallow exceptions silently with an empty catch block. At minimum, log the exception
• Use try with resources for any AutoCloseable resource like streams, connections, and readers
• Do not use exceptions for flow control. Exceptions are expensive and should only represent exceptional conditions
• Prefer unchecked exceptions for programming errors (validation failures, illegal arguments) and checked exceptions for recoverable external errors
• Include context in exception messages with specific details about what went wrong and the values involved
• Use exception chaining when catching one exception and throwing another to preserve the original cause
• Create custom exception classes for domain specific error conditions in your application
• Log exceptions at the appropriate level: ERROR for failures, WARN for recoverable issues, DEBUG for expected exceptions

Types of Classes in Java

Java supports many different types of classes, each designed for specific use cases and design patterns. Understanding when and why to use each type is fundamental to writing clean, maintainable, and efficient Java code. This knowledge is frequently tested in Java interviews across all experience levels.

1. Regular (Concrete) Class

A regular class is the most common type of class in Java. It can be instantiated directly, can extend one other class, and can implement multiple interfaces. It defines both the state (fields) and behavior (methods) of its objects.

2. Abstract Class

An abstract class cannot be instantiated directly. It serves as a base class that defines a common template for its subclasses. It can contain both abstract methods (without implementation, which subclasses must override) and concrete methods (with full implementation that subclasses inherit). Abstract classes are ideal when you want to share code among closely related classes while enforcing certain methods to be implemented differently by each subclass.

3. Final Class

A final class cannot be extended or subclassed. This is useful when you want to prevent inheritance for security, design integrity, or immutability reasons. The String class in Java is a well known example of a final class.

4. Static Nested Class

A static class defined inside another class. It behaves like a regular top level class but is logically grouped with its enclosing class for organization. It can only access static members of the outer class, not instance members.

5. Inner Class (Non Static Nested Class)

A non static class inside another class that has access to all members (including private) of the outer class. Each instance of the inner class is tied to an instance of the outer class.

6. Anonymous Inner Class

A class without a name, defined and instantiated in a single expression. Anonymous classes are useful for one time use implementations, particularly for interfaces or abstract classes with just one or two methods. Since Java 8, lambdas are preferred for single method interfaces (functional interfaces).

7. Singleton Class

The Singleton pattern ensures only one instance of a class exists throughout the application. This is commonly used for configuration managers, connection pools, logging services, and caches where having multiple instances would be wasteful or problematic.

8. Immutable Class

An immutable class is one whose state cannot be changed after it is created. String, Integer, and LocalDate are examples of immutable classes in Java. Immutable objects are inherently thread safe because their state never changes, eliminating the need for synchronization.

9. Record Class (Java 16+)

Records are a modern, concise way to create immutable data carrier classes. The compiler automatically generates the constructor, getters, equals(), hashCode(), and toString() methods. Records are perfect for DTOs, value objects, and anywhere you need a simple data container.

10. Sealed Classes (Java 17+)

Sealed classes restrict which other classes can extend or implement them. This gives you complete control over your class hierarchy and enables the compiler to perform exhaustive checks in switch expressions.

Class Types Comparison

Java Data Types

Java is a statically typed language, meaning every variable must be declared with a specific data type before it can be used. The data type determines how much memory is allocated, what values the variable can hold, and what operations can be performed on it. Java data types fall into two broad categories: primitive types (which store simple values directly) and reference types (which store references to objects on the heap).

Primitive Data Types

Java has 8 primitive data types that are built into the language. They are not objects and are stored directly on the stack for optimal performance.

Primitive Types in Action

Reference Types

Reference types store references (memory addresses) to objects on the heap rather than the actual values. All classes, interfaces, arrays, enums, and records are reference types. The reference variable itself is stored on the stack, while the object it points to is on the heap.

Primitive vs Reference Types

Type Casting

Widening (Implicit) Casting

Automatically converts a smaller type to a larger type. No data loss occurs.

Narrowing (Explicit) Casting

Requires manual casting from a larger type to a smaller type. Data loss may occur.

Wrapper Classes and Autoboxing

Every primitive type in Java has a corresponding wrapper class that wraps the primitive value in an object. Wrapper classes are needed when you want to use primitives in collections (which only accept objects), when you need null capability, or when working with generics.

Important Java Keywords

Access Modifiers

Non Access Modifiers Explained

this and super Keywords

instanceof Keyword

var Keyword: Local Variable Type Inference (Java 10+)

Enum Types

Enums in Java are special classes that represent a fixed set of constants. They are type safe, can have fields, methods, and constructors, and are implicitly final and static.