java Interview Questions

Answer:

Java is a high-level, class-based, object-oriented programming language designed to have as few implementation dependencies as possible.

Answer:

The main features of Java include platform independence, object-oriented, robust, secure, multithreaded, architecture-neutral, portable, high performance, and interpreted.

Answer:

JVM (Java Virtual Machine) is an abstract machine that enables your computer to run a Java program. It converts bytecode into machine-specific code.

Answer:

JDK (Java Development Kit) is a software development kit used to develop Java applications. It includes the JRE, an interpreter/loader, a compiler, an archiver, a documentation generator, and other tools needed for Java development.

Answer:

JRE (Java Runtime Environment) is a part of the JDK that provides the libraries, Java Virtual Machine, and other components to run applications written in Java.

Answer:

Java has four access modifiers: private, default, protected, and public. They control the visibility of classes, methods, and variables.

public class MyClass { public int myVar; private void myMethod() { /* code here */ } }

Answer:

An object is an instance of a class. It has state (attributes) and behavior (methods).

public class Car { private String color; public void drive() { System.out.println('Car is moving'); } } Car myCar = new Car();

Answer:

A class is a blueprint for objects. It defines a type of object according to the attributes and methods that the object can have.

public class Car { private String color; public void drive() { System.out.println('Car is moving'); } }

Answer:

Inheritance is a mechanism where a new class inherits the properties and behavior of an existing class. It promotes code reuse.

public class Animal { public void eat() { System.out.println('Animal is eating'); } } public class Dog extends Animal { public void bark() { System.out.println('Dog is barking'); } }

Answer:

Polymorphism allows methods to do different things based on the object it is acting upon. It is achieved through method overloading and method overriding.

public class Animal { public void makeSound() { System.out.println('Animal makes a sound'); } } public class Dog extends Animal { public void makeSound() { System.out.println('Dog barks'); } }

Answer:

Encapsulation is a principle of wrapping data (variables) and code (methods) together as a single unit. It restricts direct access to some of the object's components, which is a way of hiding the internal representation of the object.

public class MyClass { private int myVar; public int getMyVar() { return myVar; } public void setMyVar(int value) { myVar = value; } }

Answer:

Abstraction is the concept of hiding the complex implementation details and showing only the essential features of the object. It is achieved using abstract classes and interfaces.

public abstract class Shape { public abstract void draw(); }

Answer:

A constructor is a special method that is called when an object is instantiated. It initializes the object.

public class MyClass { private int myVar; public MyClass(int value) { myVar = value; } }

Answer:

Method overloading is a feature that allows a class to have more than one method with the same name, as long as their parameter lists are different.

public class MyClass { public void myMethod(int x) { System.out.println(x); } public void myMethod(int x, int y) { System.out.println(x + y); } }

Answer:

Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass.

public class Animal { public void makeSound() { System.out.println('Animal makes a sound'); } } public class Dog extends Animal { public void makeSound() { System.out.println('Dog barks'); } }

Answer:

'==' is a reference comparison operator used to check if two references point to the same object. 'equals()' is a method used to compare the contents of two objects for equality.

String str1 = new String('Hello'); String str2 = new String('Hello'); System.out.println(str1 == str2); // false System.out.println(str1.equals(str2)); // true

Answer:

An interface in Java is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. It is a way to achieve abstraction.

Answer:

An abstract class is a class that cannot be instantiated on its own and must be subclassed. It can contain both abstract methods (without implementation) and non-abstract methods (with implementation).

public abstract class Shape { public abstract void draw(); public void display() { System.out.println('Displaying shape'); } }

Answer:

A static method belongs to the class rather than instances of the class. It can be called without creating an instance of the class.

Answer:

The final keyword in Java is used to restrict the user. It can be applied to variables, methods, and classes. A final variable cannot be changed, a final method cannot be overridden, and a final class cannot be subclassed.

public final class MyClass { public final int myVar = 10; public final void myMethod() { /* code here */ } }

Answer:

An Array is a fixed-size data structure that can hold elements of the same type. An ArrayList is a resizable array, which is part of the Java Collections Framework and can dynamically grow and shrink.

int[] arr = new int[5]; ArrayList<Integer> list = new ArrayList<Integer>();

Answer:

The 'this' keyword in Java is a reference to the current object, used to differentiate between instance variables and parameters or to invoke other constructors in the same class.

public class MyClass { private int myVar; public MyClass(int myVar) { this.myVar = myVar; } }

Answer:

The 'super' keyword in Java is a reference to the parent class object, used to access the parent class's fields, methods, and constructors.

public class Child extends Parent { public Child() { super(); } }

Answer:

Exception handling is a mechanism to handle runtime errors, ensuring the normal flow of the application. It is implemented using try, catch, throw, throws, and finally blocks.

Answer:

Checked exceptions are exceptions that must be either caught or declared in the method signature. Unchecked exceptions are exceptions that are not checked at compile time, including RuntimeException and its subclasses.

public void myMethod() throws IOException { // code that may throw IOException }

Answer:

'throw' is used to explicitly throw an exception, while 'throws' is used in the method signature to declare that the method can throw specified exceptions.

public void myMethod() throws IOException { if (condition) { throw new IOException('Error'); } }

Answer:

A package in Java is a namespace that organizes classes and interfaces, preventing naming conflicts and controlling access.

package com.example.myPackage; import com.example.myPackage.MyClass;

Answer:

A 'String' in Java is an immutable object that represents a sequence of characters. It is a class in the java.lang package.

Answer:

JVM allocates memory in different areas, including Method Area, Heap, Stack, PC Registers, and Native Method Stack.

Answer:

Garbage collection in Java is the process of reclaiming the runtime unused memory automatically. The JVM manages the memory and eliminates the need for the programmer to manually deallocate memory.

System.gc();

Answer:

Multithreading is a feature in Java that allows concurrent execution of two or more threads. It is used to maximize the utilization of CPU.

Answer:

A synchronized method locks the entire method for a particular object, whereas a synchronized block locks only a specific block of code within the method. Using synchronized blocks is more granular and can lead to better performance.

Answer:

The transient keyword in Java is used to indicate that a field should not be serialized. When an object is serialized, transient fields are ignored and not included in the serialized representation.

private transient int myVar;

Answer:

The volatile keyword in Java is used to indicate that a variable's value will be modified by different threads. It ensures visibility of changes to variables across threads, preventing threads from caching variables.

private volatile boolean running = true;

Answer:

wait() is used to make the current thread release the lock and wait until another thread invokes notify() or notifyAll() on the same object. sleep() is used to pause the current thread for a specified period without releasing the lock.

synchronized (obj) { obj.wait(); } Thread.sleep(1000);

Answer:

The Java Memory Model (JMM) defines how threads interact through memory and what behaviors are allowed in concurrent programming. It specifies rules for visibility, ordering, and atomicity of variables across threads.

Answer:

ThreadLocal is a class in Java that provides thread-local variables. Each thread accessing such a variable has its own, independently initialized copy of the variable, allowing for safe usage without synchronization.

ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0); threadLocal.set(42); int value = threadLocal.get();

Answer:

A daemon thread in Java is a background thread that does not prevent the JVM from exiting when the program finishes. Daemon threads are used for tasks like garbage collection and background maintenance.

Thread daemonThread = new Thread(() -> { while (true) { /* do some background work */ } }); daemonThread.setDaemon(true); daemonThread.start();

Answer:

Serializable is a marker interface that uses default serialization mechanism, while Externalizable allows custom serialization logic by implementing readExternal() and writeExternal() methods.

public class MyClass implements Serializable { /* code here */ } public class MyClass implements Externalizable { /* code here */ }

Answer:

Comparable is used to define the natural ordering of objects by implementing the compareTo() method. Comparator is used to define custom ordering of objects by implementing the compare() method.

Answer:

HashMap is not synchronized and allows null keys and values, making it faster but not thread-safe. Hashtable is synchronized and does not allow null keys or values, making it slower but thread-safe.

HashMap<String, Integer> map = new HashMap<>(); Hashtable<String, Integer> table = new Hashtable<>();

Answer:

The Java Stream API is a feature introduced in Java 8 that allows for functional-style operations on collections and sequences of data, such as map, filter, and reduce, promoting a more declarative programming approach.

Answer:

The Optional class in Java is a container object used to represent the presence or absence of a value. It helps to avoid null checks and NullPointerExceptions by providing methods to check and manipulate the contained value.

Optional<String> optional = Optional.of('value'); if (optional.isPresent()) { String value = optional.get(); }

Answer:

A lambda expression in Java is a concise way to represent an anonymous function, which can be used to pass behavior as an argument to methods, particularly useful for functional programming with the Stream API.

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); list.forEach(n -> System.out.println(n));

Answer:

Method reference is a shorthand notation of a lambda expression to call a method. It is represented by :: and can be used for static methods, instance methods, and constructors.

Answer:

map() transforms each element in the stream and returns a stream of those transformed elements. flatMap() transforms each element into a stream and flattens the resulting streams into a single stream.

List<List<Integer>> list = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4)); List<Integer> flatList = list.stream().flatMap(Collection::stream).collect(Collectors.toList());

Answer:

CompletableFuture is a class introduced in Java 8 that represents a future result of an asynchronous computation. It provides methods to manually complete the future and handle the result or exceptions.

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> { /* computation */ }); Integer result = future.get();

Answer:

The Fork/Join Framework in Java is used for parallel execution of tasks. It works by recursively breaking down a task into smaller sub-tasks, executing them in parallel, and combining their results.

ForkJoinPool pool = new ForkJoinPool(); pool.invoke(new MyRecursiveTask());

Answer:

ExecutorService is a higher-level replacement for a thread pool, suitable for managing a pool of threads for concurrent tasks. ForkJoinPool is specialized for working with the Fork/Join Framework for divide-and-conquer tasks.

Answer:

CountDownLatch is a synchronization aid that allows one or more threads to wait until a set of operations being performed by other threads completes. It has a counter that is decremented each time a thread finishes, releasing waiting threads when it reaches zero.

Answer:

CyclicBarrier is a synchronization aid that allows a set of threads to wait for each other to reach a common barrier point. Once all threads reach the barrier, they can proceed.

Answer:

Phaser is a more flexible synchronization barrier that allows multiple threads to wait for each other at a common barrier point, supporting multiple phases and dynamic registration of parties.

Phaser phaser = new Phaser(); phaser.register(); phaser.arriveAndAwaitAdvance();

Answer:

ReentrantLock is a more advanced locking mechanism than synchronized blocks, providing additional features like lock polling, timed locks, and interruptible locks, with explicit lock and unlock control.

Answer:

Callable is similar to Runnable but can return a result and throw a checked exception. Runnable does not return a result and cannot throw checked exceptions.

Answer:

Future represents the result of an asynchronous computation and provides methods to check if the computation is complete, cancel it, and retrieve the result. CompletableFuture extends Future with additional methods for manual completion and chaining asynchronous operations.

Future<Integer> future = executor.submit(() -> { /* computation */ }); Integer result = future.get(); CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> { /* computation */ }); Integer result = future.get();

Answer:

Double Brace Initialization is a technique to initialize collections in Java using an anonymous inner class with an instance initializer. It simplifies syntax but creates an additional inner class, which can be less efficient and harder to read.

List<String> list = new ArrayList<String>() {{ add('A'); add('B'); }}; Set<Integer> set = new HashSet<Integer>() {{ add(1); add(2); }};

Answer:

The diamond operator (<>) is used to simplify the syntax of generic instance creation by allowing the compiler to infer the type arguments, introduced in Java 7.

List<String> list = new ArrayList<>(); Map<Integer, String> map = new HashMap<>();

Answer:

A WeakReference is a type of reference that does not prevent its referent from being reclaimed by the garbage collector. It is used to avoid memory leaks when caching objects.

Answer:

Soft references are cleared at the discretion of the garbage collector in response to memory demand, while weak references are cleared as soon as the referent is only weakly reachable.

Answer:

A PhantomReference is used to schedule post-mortem cleanup actions after an object has been finalized. It always returns null for get() and must be used with a ReferenceQueue.

Object obj = new Object(); ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>(); PhantomReference<Object> phantomRef = new PhantomReference<>(obj, referenceQueue);

Answer:

A Spliterator is an interface in Java that can be used for traversing and partitioning elements of a source, similar to an Iterator, but with support for parallel processing introduced in Java 8.

Answer:

The Java Memory Model (JMM) specifies how the Java Virtual Machine works with computer memory, particularly in the context of multithreading. It defines the rules for reading and writing to memory variables, ensuring that changes in one thread are visible to others. This is crucial for developing concurrent applications.

Answer:

Heap memory is used for dynamic memory allocation where objects are allocated and managed by the garbage collector. Stack memory is used for static memory allocation where method-specific variables are stored. The stack is thread-safe as each thread has its own stack, while the heap is shared among all threads.

Answer:

The garbage collector in Java automatically reclaims memory by removing objects that are no longer reachable in the program. It uses various algorithms such as Mark-and-Sweep, Generational Garbage Collection, and the G1 Garbage Collector to efficiently manage memory.

Answer:

Strong references prevent objects from being collected by the garbage collector. Weak references do not prevent garbage collection and are collected as soon as no strong references exist. Soft references are collected before an OutOfMemoryError occurs. Phantom references are collected after finalization and are used for cleanup tasks.

Object obj = new Object(); WeakReference<Object> weakRef = new WeakReference<>(obj); SoftReference<Object> softRef = new SoftReference<>(obj); PhantomReference<Object> phantomRef = new PhantomReference<>(obj, referenceQueue);

Answer:

A memory leak in Java occurs when objects that are no longer needed are still referenced, preventing the garbage collector from reclaiming memory. It can be detected using profiling tools such as VisualVM, JProfiler, and memory analysis tools in IDEs.

Answer:

The 'finalize' method is invoked by the garbage collector before an object is reclaimed. It is used to perform cleanup tasks, but its use is discouraged due to unpredictability and performance issues. Java 9 deprecated the finalize method.

@Override protected void finalize() throws Throwable { /* cleanup code */ super.finalize(); }

Answer:

The 'synchronized' keyword provides a simple way to achieve synchronization but lacks flexibility. The 'Lock' interface, introduced in java.util.concurrent.locks, offers more advanced synchronization mechanisms like timed and interruptible lock acquisition, and better performance in highly contended scenarios.

Answer:

Java has several types of class loaders, including the Bootstrap ClassLoader, Extension ClassLoader, and Application ClassLoader. Custom class loaders can also be created to load classes from unconventional sources.

Answer:

The 'invokeLater' method in Swing is used to ensure that updates to the GUI are performed on the Event Dispatch Thread (EDT). It schedules a Runnable to be executed on the EDT, maintaining thread safety in GUI applications.

SwingUtilities.invokeLater(() -> { /* update GUI components */ });

Answer:

Statement is used for executing simple SQL queries without parameters. PreparedStatement is used for executing precompiled SQL queries with parameters, providing better performance and security. CallableStatement is used to execute stored procedures in the database.

Answer:

The Java NIO (New I/O) package provides non-blocking I/O operations and improved performance for file and network I/O. Its main components include Channels, Buffers, Selectors, and Path API for efficient data handling.

Answer:

ByteBuffer is used for handling binary data, allowing manipulation of byte arrays. CharBuffer is used for handling character data, providing methods for reading and writing character sequences. Both are part of the java.nio package.

Answer:

FileChannel is part of the java.nio package and provides advanced features like non-blocking I/O, memory-mapped files, and file locking. FileInputStream/FileOutputStream are part of the java.io package and provide basic blocking I/O operations.

Answer:

The Fork/Join framework, introduced in Java 7, is designed for parallel processing by recursively splitting tasks into smaller sub-tasks (forking) and then combining the results (joining). It improves performance in multi-core systems.

Answer:

ForkJoinPool is specialized for divide-and-conquer tasks using the Fork/Join framework. ExecutorService is a higher-level interface for managing a pool of threads for concurrent tasks, providing more general-purpose concurrency management.

Answer:

Java's concurrency utilities (java.util.concurrent) provide high-level abstractions like ThreadPoolExecutor, ConcurrentHashMap, and CountDownLatch, simplifying complex concurrency patterns and improving performance compared to traditional thread management with Thread and synchronized blocks.

Answer:

ReentrantLock is a flexible locking mechanism from java.util.concurrent.locks, providing additional features like timed and interruptible lock acquisition, and explicit lock/unlock control. Synchronized blocks offer simpler, implicit locking with less flexibility.

ReentrantLock lock = new ReentrantLock(); lock.lock(); try { /* critical section */ } finally { lock.unlock(); }

Answer:

Phaser is a synchronization aid that allows threads to wait for each other at common barrier points. It supports multiple phases and dynamic registration of parties, making it more flexible than CyclicBarrier or CountDownLatch.

Answer:

Java ForkJoinPool is designed for parallel processing using the Fork/Join framework. It optimizes parallel processing by work-stealing, where idle threads steal tasks from busy threads, balancing the load and improving performance.

Answer:

The java.util.concurrent package provides high-level concurrency utilities, including thread pools, synchronization mechanisms, and concurrent collections, simplifying the development of concurrent and parallel applications with better performance and scalability.

ExecutorService executor = Executors.newFixedThreadPool(4); Future<Integer> future = executor.submit(() -> { /* computation */ });

Answer:

CyclicBarrier is a synchronization aid that allows a set of threads to wait at a common barrier point, resetting after all threads reach the barrier. CountDownLatch allows threads to wait until a count reaches zero, but it cannot be reset.

Answer:

Future represents the result of an asynchronous computation, providing methods to check if it's done and retrieve the result. CompletableFuture extends Future with additional methods for manual completion, chaining asynchronous operations, and combining multiple futures.

Answer:

A Spliterator is an interface for traversing and partitioning elements of a source for parallel processing. It supports efficient parallel iteration and splitting, unlike an Iterator, which is only suitable for sequential iteration.

Answer:

A memory barrier is a CPU instruction that ensures memory operations before the barrier are completed before operations after it begin. In Java, the volatile keyword and synchronized blocks act as memory barriers, ensuring visibility of changes across threads.

Answer:

Serializable is a marker interface using default serialization, while Externalizable requires implementing readExternal() and writeExternal() methods for custom serialization. Externalizable offers more control over the serialization process.

public class MyClass implements Serializable { /* code here */ } public class MyClass implements Externalizable { /* code here */ }

Answer:

Method handles, introduced in Java 7, are a low-level mechanism for method invocation, providing a flexible way to manipulate methods and constructors. They are used in the java.lang.invoke package for dynamic method invocation.

Answer:

Direct ByteBuffer allocates memory outside the JVM heap, allowing more efficient I/O operations by avoiding copying data between the JVM and native memory. Non-direct ByteBuffer allocates memory on the JVM heap, which may involve extra copying during I/O operations.

ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024); ByteBuffer nonDirectBuffer = ByteBuffer.allocate(1024);

Answer:

VarHandles, introduced in Java 9, provide a mechanism to access fields and array elements with flexible and safe operations, similar to method handles. They offer fine-grained control over memory operations, including atomic and volatile access.

Answer:

Functional interfaces are interfaces with a single abstract method, used as the target type for lambda expressions and method references. Lambda expressions provide a concise way to implement functional interfaces, representing instances of the interface.

Answer:

The 'default' keyword allows interfaces to have concrete methods, providing default implementations that can be overridden by implementing classes. It enables backward compatibility and code reuse without breaking existing implementations.

public interface MyInterface { default void myMethod() { /* default implementation */ } }