Question 1

What is Java and why is it platform-independent?

Accepted Answer

Java is a high-level, object-oriented programming language developed by Sun Microsystems (now Oracle). It is platform-independent because Java source code is compiled into bytecode, which runs on the Java Virtual Machine (JVM). The JVM acts as an abstraction layer between the bytecode and the underlying hardware/OS, allowing the same bytecode to run on any system that has a JVM. This principle is known as 'Write Once, Run Anywhere' (WORA).

Question 2

Explain the JVM, JRE, and JDK and their differences.

Accepted Answer

JVM (Java Virtual Machine) is the runtime engine that executes Java bytecode. JRE (Java Runtime Environment) includes the JVM plus standard libraries and other components needed to run Java applications. JDK (Java Development Kit) includes the JRE plus development tools (compiler, debugger, etc.). In short: JDK contains JRE, JRE contains JVM. Developers need JDK; end-users need JRE.

Question 3

What are the main principles of Object-Oriented Programming (OOP) in Java?

Accepted Answer

OOP principles are: 1) Encapsulation – bundling data and methods within objects, hiding internal state. 2) Inheritance – creating new classes based on existing ones to reuse code. 3) Polymorphism – ability of objects to take many forms (method overloading and overriding). 4) Abstraction – hiding implementation details and exposing only essential features (abstract classes, interfaces).

Question 4

What is the difference between a class and an object?

Accepted Answer

A class is a blueprint or template that defines the properties (attributes) and behaviors (methods) common to all objects of a certain kind. An object is an instance of a class—a concrete entity created from the class using the 'new' keyword. A class defines the structure; an object occupies memory and has state.

Question 5

Explain constructors in Java. What are the types?

Accepted Answer

A constructor is a special method used to initialize objects when they are created. It has the same name as the class and no return type. Types: 1) Default constructor (no arguments) – provided by the compiler if not explicitly defined. 2) Parameterized constructor – accepts arguments to initialize instance variables. 3) Copy constructor – constructs a new object by copying another object.

Question 6

What is method overloading and method overriding?

Accepted Answer

Method overloading (compile-time polymorphism) occurs when multiple methods in the same class have the same name but different parameters (number, type, or order). Method overriding (runtime polymorphism) occurs when a subclass provides a specific implementation of a method that is already defined in its superclass, using the same name and parameters. Overriding requires inheritance.

Question 7

What is the 'super' keyword and how is it used?

Accepted Answer

The 'super' keyword is used in a subclass to refer to the immediate parent class. It can be used to: call parent class constructors (super()), access parent class methods, and access parent class fields. It's essential for avoiding name conflicts and for invoking overridden methods.

Question 8

What is the 'final' keyword in Java and how is it used?

Accepted Answer

The 'final' keyword can be applied to: variables (makes them constants, cannot be reassigned), methods (prevents overriding), and classes (prevents inheritance). It's used to enforce immutability, improve security, and optimize performance.

Question 9

Explain the difference between abstract classes and interfaces.

Accepted Answer

Abstract classes can have both abstract and concrete methods, can have instance variables, and can define constructors. A class can extend only one abstract class. Interfaces can have only abstract methods (prior to Java 8), but from Java 8 they can have default and static methods; fields are implicitly public, static, final. A class can implement multiple interfaces. Abstract classes are for partial implementation; interfaces define a contract.

Question 10

What is the difference between checked and unchecked exceptions?

Accepted Answer

Checked exceptions are checked at compile-time; the programmer must handle them (try-catch or declare with throws). They represent recoverable conditions (e.g., IOException, SQLException). Unchecked exceptions (RuntimeException and its subclasses) are not checked at compile-time; they represent programming errors (e.g., NullPointerException, ArrayIndexOutOfBoundsException).

Question 11

What is the purpose of the 'finally' block?

Accepted Answer

The 'finally' block is optional and follows try-catch. It always executes regardless of whether an exception is thrown or caught, unless the JVM exits abruptly. It's used to release resources like file streams, database connections, or to perform cleanup actions.

Question 12

Explain the difference between 'throw' and 'throws'.

Accepted Answer

'throw' is used to explicitly throw an exception from a method or block. It is followed by an instance of Throwable. 'throws' is used in a method signature to declare that the method may throw one or more exceptions, delegating handling to the caller.

Question 13

What is the Java memory model and how does garbage collection work?

Accepted Answer

The Java memory model divides memory into: Heap (objects), Stack (method frames, local variables), Method Area (class metadata, static variables), Program Counter (current instruction), and Native Method Stacks. Garbage collection automatically reclaims memory occupied by objects that are no longer reachable. The JVM uses algorithms like Mark-and-Sweep, generational collection (young, old, permanent/metaspace), and different garbage collectors (G1, CMS, ZGC).

Question 14

What is the difference between '=='' and 'equals()' in Java?

Accepted Answer

'==' is a reference comparison: it checks if two references point to the same memory location. 'equals()' is a method defined in Object that can be overridden to compare the contents or state of two objects (e.g., String uses it for value comparison). For primitive types, '==' compares values. For objects, unless overridden, 'equals()' behaves like '=='. Always override equals() when defining logical equality.

Question 15

Explain the 'String' class and its immutability.

Accepted Answer

Strings in Java are immutable—once created, their value cannot be changed. Any operation that seems to modify a String creates a new String object. This improves security, caching (String pool), and thread-safety. For mutable strings, use StringBuilder (non-synchronized) or StringBuffer (thread-safe).

Question 16

What is the String pool and how does it work?

Accepted Answer

The String pool (intern pool) is a special memory area in the heap where Java stores String literals. When a String literal is created (e.g., 'Hello'), the JVM checks the pool; if the literal already exists, the reference is reused. This saves memory. Strings created with 'new String()' are not pooled automatically but can be interned using 'intern()'.

Question 17

What are the different access modifiers in Java?

Accepted Answer

Access modifiers control visibility: 'private' (same class only), 'default' (package-private, same package), 'protected' (same package + subclasses), 'public' (anywhere). They are essential for encapsulation and API design.

Question 18

What is the 'static' keyword and how is it used?

Accepted Answer

The 'static' keyword belongs to the class rather than instances. It can be applied to variables (class variables), methods (can be called without instance), blocks (static initialization), and nested classes. Static members are shared among all instances of the class.

Question 19

Explain the concept of singleton pattern and how to implement it in Java.

Accepted Answer

Singleton ensures a class has only one instance and provides a global point of access. Implementations: 1) Eager initialization (instance created at class loading), 2) Lazy initialization with double-checked locking, 3) Bill Pugh Singleton (using static inner class), 4) Enum Singleton (most robust). The pattern is used for logging, configuration, connection pools.

Question 20

What is the difference between ArrayList and LinkedList?

Accepted Answer

ArrayList is backed by a dynamic array; it provides O(1) random access but O(n) for insertion/deletion in the middle. LinkedList is a doubly-linked list; it provides O(1) insertion/deletion at ends but O(n) for random access. ArrayList is better for frequent read operations; LinkedList for frequent additions/removals.

Question 21

Explain the differences between HashMap, Hashtable, and ConcurrentHashMap.

Accepted Answer

HashMap is not synchronized (not thread-safe), permits null keys/values. Hashtable is synchronized (thread-safe), does not permit null. ConcurrentHashMap is thread-safe and allows high concurrency by segmenting locks; it's preferred in concurrent environments. For non-concurrent use, use HashMap.

Question 22

What is the purpose of the 'transient' keyword?

Accepted Answer

The 'transient' keyword marks a field as not serializable. When an object is serialized, transient fields are skipped, preventing sensitive data from being persisted and improving performance for non-essential fields.

Question 23

Explain the 'volatile' keyword in Java.

Accepted Answer

The 'volatile' keyword ensures that a variable's value is always read from main memory, not from thread-local caches. It provides visibility guarantees across threads. It is used for flags, status variables, and in lock-free programming, but does not guarantee atomicity.

Question 24

What is the difference between synchronized methods and synchronized blocks?

Accepted Answer

Synchronized methods lock the entire method on the current instance (or class for static). Synchronized blocks lock a specific object, allowing finer-grained control and better performance. Blocks are more flexible and can reduce contention.

Question 25

Explain the Producer-Consumer problem and how to solve it in Java.

Accepted Answer

The Producer-Consumer problem involves two threads: one producing data, the other consuming it, with a shared buffer. It requires synchronization to avoid race conditions. Solutions: 1) Using wait()/notify() on a shared object, 2) Using BlockingQueue implementations (ArrayBlockingQueue, LinkedBlockingQueue) which handle synchronization automatically, 3) Using Semaphores.

Question 26

What are the differences between Runnable and Callable?

Accepted Answer

Runnable has a run() method that returns void and cannot throw checked exceptions. Callable has a call() method that returns a generic value and can throw exceptions. Callable is used with ExecutorService for tasks that need to return results.

Question 27

What is the Executor framework in Java?

Accepted Answer

The Executor framework (java.util.concurrent) provides a higher-level API for thread management. It decouples task submission from execution. Key interfaces: Executor, ExecutorService, ScheduledExecutorService. Common implementations: ThreadPoolExecutor, ScheduledThreadPoolExecutor. It simplifies managing thread pools and reduces overhead of creating threads manually.

Question 28

What is the difference between 'sleep()' and 'wait()'?

Accepted Answer

sleep() is a method of Thread that pauses execution for a specified time; it does not release the lock. wait() is a method of Object that releases the lock and waits until notified; it must be called from a synchronized context. sleep() is for timing, wait() is for inter-thread communication.

Question 29

Explain the 'try-with-resources' statement.

Accepted Answer

try-with-resources automatically closes resources that implement AutoCloseable (e.g., FileInputStream, Connection, Scanner). It is declared with try (ResourceType res = new ResourceType()) { ... }. Resources are closed in reverse order, ensuring proper cleanup even if exceptions occur. It was introduced in Java 7.

Question 30

What are Java 8 features?

Accepted Answer

Key Java 8 features: Lambda expressions, Stream API, Functional interfaces, Default and static methods in interfaces, Optional class, new Date/Time API (java.time), Nashorn JavaScript engine, and CompletableFuture for asynchronous programming.

Question 31

Explain lambda expressions and functional interfaces.

Accepted Answer

Lambda expressions provide a concise way to represent anonymous functions. They are used to implement functional interfaces (interfaces with a single abstract method). Example: (x, y) -> x + y. Common functional interfaces: Predicate, Consumer, Supplier, Function. They enable functional programming and simplify code.

Question 32

What is the Stream API and how is it used?

Accepted Answer

The Stream API provides a declarative way to process sequences of data (collections, arrays). It supports operations like filter, map, reduce, collect, sorted, etc. Streams can be sequential or parallel. They allow functional-style operations on data and are lazy (intermediate operations are not executed until a terminal operation is invoked).

Question 33

What is the Optional class and why is it useful?

Accepted Answer

Optional is a container object that may or may not contain a non-null value. It helps avoid NullPointerException by forcing explicit handling of absent values. Methods: ofNullable, orElse, orElseGet, orElseThrow, map, flatMap. It promotes cleaner code and encourages proper null handling.

Question 34

Explain the new Date/Time API in Java 8.

Accepted Answer

The java.time package (inspired by Joda-Time) provides immutable classes for date and time: LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Instant, Duration, Period. It is thread-safe, provides fluent methods for manipulation, and supports time zones and formatting via DateTimeFormatter.

Question 35

What is the difference between Collection and Collections in Java?

Accepted Answer

Collection is the root interface of the collection framework (List, Set, Queue). Collections is a utility class that provides static methods for operations on collections (sort, reverse, shuffle, binarySearch, etc.).

Question 36

Explain the differences between HashSet and TreeSet.

Accepted Answer

HashSet is backed by a hash table, offers O(1) average time for add, remove, contains, and does not guarantee order. TreeSet is backed by a TreeMap (red-black tree), maintains sorted order, and has O(log n) time for operations. HashSet is for fast lookups; TreeSet for sorted order.

Question 37

What is the difference between Iterator and ListIterator?

Accepted Answer

Iterator can traverse forward only (hasNext, next, remove). ListIterator extends Iterator and allows bidirectional traversal (hasPrevious, previous, nextIndex, previousIndex), and supports adding and setting elements. ListIterator is only available for List collections.

Question 38

What is the garbage collector and what are the different types?

Accepted Answer

Garbage collection (GC) automatically deallocates unreferenced objects. Types: Serial GC (single-threaded), Parallel GC (multi-threaded, throughput-oriented), CMS (Concurrent Mark-Sweep, low-pause), G1 (Garbage-First, predictable pause times), ZGC (low-latency, scalable), Shenandoah. Each has trade-offs between throughput, pause time, and memory footprint.

Question 39

Explain the 'ClassLoader' in Java.

Accepted Answer

ClassLoaders are responsible for dynamically loading Java classes into the JVM during runtime. There are three built-in: Bootstrap (loads rt.jar), Extension (loads extensions), System/Application (loads classpath). ClassLoaders follow the delegation model—they ask their parent to load the class before trying themselves.

Question 40

What is the purpose of the 'native' keyword?

Accepted Answer

The 'native' keyword indicates that a method is implemented in platform-specific code (e.g., C/C++) using the Java Native Interface (JNI). It is used for performance-critical operations or to access system-level resources not available in Java.

Question 41

What are annotations in Java and how are they used?

Accepted Answer

Annotations are metadata that provide information about code (e.g., @Override, @Deprecated, @SuppressWarnings). They can be processed at compile-time or runtime. Custom annotations can be defined using @interface and can have retention policies (SOURCE, CLASS, RUNTIME).

Question 42

Explain the difference between heap and stack memory.

Accepted Answer

Heap memory is used for dynamic allocation of objects; it is shared across threads and managed by the garbage collector. Stack memory is used for method execution; each thread has its own stack, storing local primitives, references, and method frames. Stack memory is faster but limited; heap is larger but slower.

Question 43

What is the 'this' keyword and when is it used?

Accepted Answer

The 'this' keyword is a reference to the current object. It is used to differentiate instance variables from local variables, to call another constructor of the same class (this()), and to pass the current object as a parameter. It cannot be used in static contexts.

Question 44

What is the 'instanceof' operator used for?

Accepted Answer

The 'instanceof' operator checks whether an object is an instance of a specific class or implements a specific interface. It returns a boolean. It is commonly used before casting to avoid ClassCastException.

Question 45

Explain the concept of reflection in Java.

Accepted Answer

Reflection is the ability to inspect and manipulate classes, methods, fields, and constructors at runtime. The java.lang.reflect package provides classes like Class, Method, Field, Constructor. It is used for frameworks, dependency injection, serialization, and testing. It can break encapsulation and has performance overhead.

Question 46

What is the difference between shallow copy and deep copy?

Accepted Answer

Shallow copy copies the object's reference fields (primitives are copied directly) but not the objects they refer to. The clone() method (default) does a shallow copy. Deep copy duplicates the entire object graph, including referenced objects, by recursively copying them. It can be achieved by implementing Cloneable and overriding clone() or by serialization.

Question 47

Explain the concept of 'immutability' in Java with an example.

Accepted Answer

An immutable object cannot be modified after creation. Examples: String, wrapper classes (Integer, Double), LocalDate, LocalTime. Benefits: thread-safety, easy caching, security. To make a class immutable: declare class final, fields private final, don't provide setters, ensure no methods modify fields, make defensive copies.

Question 48

What is the difference between Comparator and Comparable?

Accepted Answer

Comparable is implemented by the class itself (natural ordering) and defines compareTo(). It provides a single sorting order. Comparator is an external interface used to define custom ordering; it can be passed to sorting methods. Comparator is useful for multiple sorting strategies and for sorting classes not implementing Comparable.

Question 49

What is the 'serialVersionUID' and why is it important?

Accepted Answer

serialVersionUID is a unique identifier for a serializable class. It is used during deserialization to verify that the sender and receiver have compatible classes. If not defined, the JVM generates one based on class details, which can change and cause InvalidClassException. It's best practice to define it explicitly.

Question 50

Explain the concept of 'dependency injection' in Java.

Accepted Answer

Dependency Injection (DI) is a design pattern where objects receive their dependencies from an external source rather than creating them internally. It promotes loose coupling and testability. Implementations: constructor injection, setter injection, method injection. Frameworks like Spring and CDI provide DI containers.

Question 51

What are the benefits and use cases of Java's CompletableFuture?

Accepted Answer

CompletableFuture is a class in java.util.concurrent that supports asynchronous programming. It allows chaining of tasks, combining multiple futures, handling exceptions, and providing callbacks. Benefits: non-blocking, easily composable, better resource utilization. Use cases: web services, database calls, parallel computations, event-driven systems.

Java Interview Q&A