Java Features Interview Questions

Mastering Java core features is essential for technical interviews, as they form the foundation of robust backend development and enterprise-level architecture design. This article compiles the most frequently asked interview questions covering fundamental mechanics, object-oriented programming (OOP), and advanced Java features.

What is the platform-independent nature of Java, and how does it work?

Java achieves platform independence through the Java Virtual Machine (JVM), encapsulated by the famous principle: "Write Once, Run Anywhere" (WORA).

• When Java source code (.java) is compiled, it is translated into an intermediate, platform-neutral format called bytecode (.class).
• The JVM, tailored specifically for each underlying operating system (such as Windows, Linux, or macOS), interprets or compiles this bytecode into native machine instructions at runtime. Consequently, developers only need to ensure a compatible JVM is installed on the target environment.

What are the eight primitive data types in Java?

Java features eight built-in primitive types, categorized by their memory footprint and default value domains:

Explain Autoboxing and Unboxing. What pitfalls should you avoid?

• Autoboxing: The automatic conversion of a primitive type into its corresponding wrapper class (e.g., int to Integer).
• Unboxing: The automatic conversion of a wrapper object back into a primitive value (e.g., Integer to int).

Potential Pitfalls:

1. NullPointerException: Unboxing a null wrapper reference throws a runtime exception (e.g., Integer num = null; int val = num;).
2. Wrapper Caching: Java caches wrapper objects for specific ranges (e.g., -128 to 127 for Integer). Comparing values outside this range using == evaluates to false because distinct object instances are created in memory, whereas .equals() should be used for value comparison.

Why is String immutable in Java, and what are the benefits?

A String is immutable because its internal character array (value[]) is declared with the private final modifiers, and the class provides no mutator methods to alter its state.

Key Benefits:

• Thread Safety: Immutable objects can be shared across multiple threads safely without synchronization overhead.
• String Pool Optimization: Identical string literals can be reused via the String Constant Pool, significantly reducing memory consumption.
• Caching Hash Codes: Since the contents never change, the hash code is calculated once and cached, boosting performance in hash-based data structures like HashMap.

What distinguishes String, StringBuffer, and StringBuilder?

• String: Immutable; every modification creates a new object, resulting in high garbage collection overhead for frequent string manipulations.
• StringBuffer: Mutable and thread-safe due to synchronized methods, making it suitable for multi-threaded environments but slower than its non-synchronized counterpart.
• StringBuilder: Mutable and unsynchronized; it offers optimal performance for string concatenation tasks within a single thread.

How does Java's exception hierarchy function, and what differentiates Checked from Unchecked exceptions?

All exceptions descend from the Throwable root class, branching into two main categories:

1. Error: Represents severe, irrecoverable system failures (e.g., OutOfMemoryError, StackOverflowError) that applications should not attempt to catch.
2. Exception: Represents conditions that applications might want to handle:
   • Checked Exceptions: Enforced at compile-time (e.g., IOException, SQLException), requiring explicit handling via try-catch blocks or throws declarations.
   • Unchecked Exceptions: Subclasses of RuntimeException (e.g., NullPointerException, ArrayIndexOutOfBoundsException) that occur due to logical flaws and are not checked at compile-time.

2. Object-Oriented Programming (OOP) Features

What are the three core pillars of OOP in Java?

1. Encapsulation: Hiding an object's internal state and requiring all interactions to be performed through defined public interfaces (such as getters and setters), thus preserving data integrity.
2. Inheritance: Allowing a subclass to inherit fields and methods from a superclass to promote code reusability. Java enforces single class inheritance while permitting multiple interface implementation.
3. Polymorphism: The ability of an entity to take multiple forms. Runtime polymorphism relies on method overriding and dynamic dispatch, allowing a superclass reference variable to point to a subclass object.

Compare Abstract Classes and Interfaces.

• Inheritance: A class can extend only one abstract class (single inheritance), but it can implement multiple interfaces (multiple inheritance of type).
• Constructors: Abstract classes can have constructors used during subclass initialization, whereas interfaces cannot have constructors.
• State: Abstract classes can contain instance variables with varying access modifiers, while interface variables are implicitly public static final.
• Method Evolution: Java 8 introduced default and static methods to interfaces, narrowing the behavioral gap between them and abstract classes.

3. Advanced Java Features

What are Generics, and why are they used?

Generics enable types (classes and methods) to be parameterized when defining classes, interfaces, and methods.

Core Advantages:

• Type Safety: Catches type mismatch errors at compile-time rather than runtime.
• Elimination of Casts: Removes the need for explicit type casting when retrieving elements from collections.
• Code Reusability: Allows writing algorithms and data structures that can operate on any data type.

How do Lambda Expressions operate, and what is a Functional Interface?

Introduced in Java 8, Lambda expressions provide a concise, functional syntax to implement anonymous methods. They depend entirely on Functional Interfaces—interfaces containing exactly one abstract method (often verified using the @FunctionalInterface annotation).

By streamlining boilerplate code, lambdas work seamlessly with the Stream API to facilitate expressive, declarative data processing.