Java Interview Questions

Java is not a pure object-oriented language because it supports primitive data types like int and char, which are not objects. In a pure object-oriented language, everything is treated as an object, but Java includes both primitive types and objects.

Java is not considered a complete object-oriented programming language because it supports primitive data types and has features like static methods and variables. In a complete object-oriented language, everything is treated as objects, and there are no primitive types or non-object-oriented features.

Java avoids pointers for security and robustness. Pointers in languages like C/C++ can lead to memory-related errors like segmentation faults and dangling pointers. By using references and managing memory automatically through a garbage collector, Java provides a safer programming environment.

An infinite loop in Java can be created using a while loop with a condition that always evaluates to true.
For example:

java

while(true) {
// Code for the infinite loop
}

Constructor overloading in Java involves creating multiple constructors within a class, each with a different parameter list. This allows objects of the class to be instantiated in various ways, providing flexibility in object creation.

A copy constructor in Java is a constructor that takes an object of the same class as a parameter and creates a new object with the same state as the provided object. It is used to perform a deep copy, creating a new instance independent of the original.

Yes, the main method in Java can be overloaded by defining multiple main methods within the same class with different parameter lists. However, only the standard

public static void main(String[] args)

method is executed when the Java program is run.

Method overloading is the practice of declaring several methods within a single class, sharing the same name but having distinct parameter lists. On the other hand, method overriding takes place when a subclass furnishes a unique implementation for a method already present in its superclass. Overloading enhances readability, while overriding supports polymorphism.

In Java, a try block is used to enclose a block of code that may throw exceptions. Multiple catch blocks can follow a single try block, each handling a specific type of exception. This allows for different exception types to be caught and handled differently, promoting better error handling.

In Java, the final keyword is used to indicate that a variable, method, or class cannot be modified, overridden, or extended, respectively. Once a variable is declared as final, its value cannot be altered; similarly, a final method is immune to being overridden, and a final class cannot be extended.

No, they have different functions. final is a keyword used for variables, methods, and classes as explained earlier. finally is used in exception handling to define a block of code that will be executed whether an exception is thrown or not. finalize is a method in the Object class that is called by the garbage collector before an object is reclaimed, but it's not commonly used.

Yes, there are cases where the finally block may not be executed. One such case is when the JVM exits due to a call to System.exit() within the try or catch block, preventing the execution of any subsequent code, including the finally block.

The super keyword in Java is used to refer to the superclass (parent class) members—fields or methods. It is typically used in a subclass to access the overridden methods or to call the superclass constructor.

Yes, static methods in Java can be overloaded. Overloading occurs when there are multiple methods in the same class with the same name but different parameter lists. The choice of which method to call is determined at compile-time based on the method signature.

The main method in Java is declared as static to allow it to be called without creating an instance of the class. When a Java program starts, it doesn't have an object instance because the main method is the entry point. Making it static ensures that the method can be invoked without the need for object instantiation.

No, static methods in Java cannot be overridden. While a subclass can declare a static method with the same signature as a static method in its superclass, it is considered hiding, not overriding. The choice of which method to call is determined at compile-time based on the reference type.

Static methods are associated with a class rather than an instance and can be called using the class name. Shared among all instances of a class, static variables are accessible using the class name.

The primary goal of garbage collection in Java is to automatically reclaim memory occupied by objects that are no longer reachable or in use by the program. It helps in managing memory efficiently, preventing memory leaks, and improving the overall performance of Java applications.

A ClassLoader in Java is a part of the Java Runtime Environment (JRE) that dynamically loads Java classes into the Java Virtual Machine (JVM) during runtime. The task of locating and loading class files into memory, enabling their execution, falls under its responsibility.

Garbage collection in Java primarily cleans up the heap memory. Objects that are no longer referenced or reachable are identified and removed from the heap by the garbage collector. Stack memory, on the other hand, is automatically managed and cleaned up as methods complete their execution.

In Java, shallow copy and deep copy refer to copying objects in different ways:

• Shallow Copy: A shallow copy creates a new object but does not duplicate the content of the object. Instead, it copies references to the original object's fields. Changes made to the fields in the copied object will affect the original, and vice versa.
• Deep Copy: A deep copy creates a completely independent copy of an object, including all its nested objects. Changes made to the fields in the copied object do not affect the original. Achieving a deep copy often involves recursively copying all referenced objects.

A singleton class in Java is a class that allows only one instance to be created and provides a global point to that instance. To implement a singleton class, you typically follow these steps:

Ensure that the constructor is set to private to deter direct instantiation.

Create a static method within the class that either creates a new instance if none exists or returns the existing instance.

Ensure thread-safety, especially in a multi-threaded environment, by using synchronized blocks or other techniques.

java

Option 1: int x = 10, y = 20;
if (x > y) {
System.out.println("x is greater");
} else
System.out.println("y is greater");
System.out.println("Comparison complete");

Option 2: int a = 5, b = 7;
if (a < b)
System.out.println("a is smaller");
else
System.out.println("b is smaller");
System.out.println("Comparison complete");

Option 1 will result in a compile-time error. The reason is that the indentation misleads the compiler, and it considers only the immediately following statement as part of the 'else' block. So, the second System.out.println("Comparison complete"); is outside any block, causing a syntax error.

• String: Immutable, meaning once created, the value cannot be changed. Thread-safe but less efficient for frequent modifications.
• StringBuffer: Mutable and thread-safe. Slower than StringBuilder due to synchronization.
• StringBuilder: Mutable but not thread-safe. Faster than StringBuffer because it's not synchronized. Ideal for single-threaded operations with frequent modifications.

• Interfaces: Support multiple inheritance, contain only abstract methods (prior to Java 8), support default and static methods from Java 8 onward, cannot have instance variables (except constants).
• Abstract classes: Support single inheritance, can have both abstract and concrete methods, can have instance variables, may contain constructors.

java

public class CompileErrorExample {
public static void main(String[] args) {
int x = 10;
System.out.println("The value of x is: " + x)
}
}

Yes, the program will give a compile-time error. The reason is a missing semicolon (;) at the end of the System.out.println statement. It will generate 1 error.

A Comparator in Java is an interface used to define custom ordering rules for objects. It provides a way to compare two objects and determine their relative order. Comparators are often used with sorting algorithms, such as Collections.sort() or Arrays.sort(), to impose a specific order on elements that do not naturally have a built-in order.

The statement is incorrect. In Java, static methods cannot be overridden as they are associated with the class, not with the instance. Private methods, though introduced in Java 9, are not overridden in the traditional sense. They are not accessible outside the class, and their definitions in subclasses do not override the private methods in the superclass.

• HashSet: Implements the Set interface, does not guarantee any specific order of elements, allows at most one null element.
• TreeSet: Implements the Set interface and navigable interface, orders elements based on their natural order or a provided comparator, does not allow null elements.

A character array is favored over a string for safeguarding confidential information because strings are immutable in Java. Once a string is created, it stays in the memory until garbage collected, and during this time, it could be accessed or intercepted. In contrast, character arrays allow for more control. You can overwrite the array with zeros or other characters after using the confidential information, reducing the risk of exposure.

The Java Development Kit (JDK) file contains tools, executables, and binaries necessary for developing, compiling, debugging, and running Java programs. It includes the Java Runtime Environment (JRE), the Java Compiler (javac), the Java Virtual Machine (JVM), and various libraries and tools needed for Java development.

• JVM (Java Virtual Machine): Executes Java bytecode, provides platform independence, and is responsible for memory management and garbage collection.
• JRE (Java Runtime Environment): Includes the JVM and necessary libraries, but lacks development tools like compiler and debugger.
• JDK (Java Development Kit): Comprehensive package containing the JRE, development tools (compiler, debugger), and additional libraries for Java development.

• HashMap: Allows null values and one null key, not synchronized (not thread-safe), faster, introduced in Java 1.2.
• HashTable: Does not allow null keys or values, synchronized (thread-safe), slower than HashMap due to synchronization, considered legacy, introduced in Java 1.0.

Reflection in Java allows dynamic inspection and manipulation of classes, methods, fields, and interfaces at runtime. It enables features like:

• Dynamic instantiation of classes.
• Retrieving and modifying field values.
• Invoking methods dynamically.

Examining and accessing annotations.

• Reflection is crucial for frameworks like Spring and tools that require runtime analysis of class structures.

Threads in Java can be used in two main ways:

• Extending the Thread class: By creating a class that extends the Thread class and overriding its run() method.
• Implementing the Runnable interface: By creating a class that implements the Runnable interface and providing the implementation for the run() method. This approach is more flexible as it allows a class to extend another class.

Thread priorities in Java range from Thread.MIN_PRIORITY (1) to Thread.MAX_PRIORITY (10), with Thread.NORM_PRIORITY (5) as the default. The priorities help the scheduler determine the order of execution when multiple threads are competing for CPU time.

• Program: A set of instructions written in a programming language, stored as a file. It is a passive entity.
• Process: An instance of a program in execution. It has its memory space, resources, and runs independently. A program can have multiple processes.

• throw: Used to explicitly throw an exception in a method. It is followed by an instance of an exception class.
• throws: Used in method signature to declare the exceptions that a method might throw. It specifies the exceptions a method can propagate, allowing the calling code to handle them.

• Constructor: Special method invoked when an object is created. It has the same name as the class, no return type, and is used for initializing object properties.
• Method: General-purpose member function of a class, used for performing actions. It has a return type, a name, and may take parameters.

Java

public class OutputExample {
public static void main(String[] args) {
int x = 5;
System.out.println(x++); // Post-increment, prints current value of x, then increments
System.out.println(++x); // Pre-increment, increments x first, then prints the new value
}
}

The output will be:
5
7
This is because the post-increment (x++) prints the current value of x and then increments it, while the pre-increment (++x) increments x first and then prints the new value.

Java uses "pass by value". When passing parameters to a method, a copy of the actual parameter value is passed. For primitive types, this means passing the actual value, while for objects, it's the reference to the object's memory location that gets passed. However, the reference itself is still passed by value.

The "IS-A" relationship in Java signifies inheritance. If Class A extends Class B, it implies that an object of Class A "is a" Class B. It establishes a relationship where the subclass inherits the attributes and behaviors of the superclass. For example, if a Car extends a Vehicle, a Car is a Vehicle.

StringBuffer should be preferred when frequent updates are needed in the data. Unlike strings, which are immutable and require creating new objects for each modification, StringBuffer is mutable, allowing efficient modifications without creating new instances.

To prevent the serialization of attributes of a class in Java, mark the attributes as transient. The transient keyword tells the serialization mechanism to exclude the marked fields from the serialization process. For example:

Java
private transient String confidentialData;

If the static modifier is omitted from the main method signature in Java, the program will not compile. The main method must be declared as public static void main(String[] args) for the Java Virtual Machine (JVM) to recognize it as the entry point of the program.

Java

public class OutputEvaluation {
public static void main(String[] args) {
String s1 = "Hello";
String s2 = new String("Hello");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
}
}

The output will be:
Arduino
false
true

This is because == compares references, and since s1 is a literal and s2 is created using new, they refer to different objects. However, equals() compares the content, so it returns true since both strings have the same sequence of characters.

Yes, it is possible to designate the main() thread as a daemon thread in Java. You can use the setDaemon(true) method to mark a thread (including the main() thread) as a daemon thread. Daemon threads are background threads that do not prevent the program from exiting if they are the only threads running.

If there are multiple main methods in one Java class, the program will compile successfully. However, when executing the program, the JVM will look for the main method with the following signature:

Java
public static void main(String[] args)
It will only execute the main method that matches this signature, ignoring others.

The process of object cloning in Java entails generating a precise duplicate of an object. To achieve cloning, a class must implement the Cloneable interface and override the clone() method. The process involves:

• Implementing the Cloneable interface.
• Overriding the clone() method in the class.
• Calling the clone() method to create a copy.

For example:
Java
public class MyClass implements Cloneable {
// Fields and methods
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}

Exception propagation in Java occurs when an exception is thrown in a method but not caught locally. The exception propagates up the call stack until it encounters a matching catch block or until it reaches the top-level of the program. If the exception is not caught, the program terminates, and the exception details are printed to the console.

If exceptions are left unhandled in a program, it can result in the termination of the program. When an exception occurs and is not caught by an appropriate catch block, it propagates up the call stack. If the exception reaches the top-level of the program without being caught, the program terminates abruptly. Additionally, unhandled exceptions can leave the program in an inconsistent state and may lead to unexpected behavior.

In Java, a try block must be followed by either a catch block or a finally block, or both. The purpose of the try-catch statement is to handle exceptions. If a try block is used, there should be at least one catch block or a finally block to manage the exceptional situation. The catch block handles the exception, and the finally block (if present) is executed regardless of whether an exception occurred or not.

Java
public class FinallyExample {
public static void main(String[] args) {
try {
// Code that may throw an exception
return;
} catch (Exception e) {
// Catch block
} finally {
System.out.println("Finally block executed");
}
}
}

Yes, the finally block will get executed even when the return statement is present in the try block. The final block is designed to execute regardless of whether an exception is thrown or not, and even if a return statement is encountered.

Yes, a constructor of a class can be called inside another constructor using the this() keyword. This is known as constructor chaining. It allows a constructor to invoke another constructor of the same class, either from the same class or from its superclass (using super()), providing a way to reuse code and initialize different parts of the object.

Contiguous memory locations are commonly used for storing actual values in an array because array elements are of the same data type, and their memory addresses can be calculated based on the index. This allows for constant-time random access.

On the other hand, ArrayList in Java uses an underlying array that might need to be resized dynamically. As elements are added or removed, the ArrayList may need to allocate a new array and copy elements, which may result in non-contiguous memory locations. This flexibility in resizing comes at the cost of potential performance overhead compared to arrays.

The decision to start array indices from 0 in Java is rooted in simplicity and consistency with low-level programming concepts. In many programming languages, including C (which influenced Java), arrays are implemented as pointers or offsets, and the index represents the offset from the beginning of the array. Starting from 0 makes calculations simpler and aligns with the concept of addressing the first element at the memory address of the array.

The remove method is generally faster in a linked list compared to an array because, in a linked list, removing an element involves updating only the references of the neighboring nodes. In contrast, in an array, removing an element at a specific index may require shifting all the subsequent elements to fill the gap, resulting in a higher time complexity.

Linked lists excel at insertions and removals in the middle, while arrays are more efficient for random access. The choice depends on the specific requirements of the application.

In the List interface, there are multiple overloaded versions of add() and addAll() methods. These include variations with index parameters, as well as those taking collections or varargs.

• addElement(E element): Adds the specified element to the conclusion of the list.
• add(E element): Appends the specified element to the end of the list.

Similarly, for addAll():

• addAll(int index, Collection<? extends E> c):Adds all the elements of the specified collection at the specified position.
• addAll(Collection<? extends E> c): Appends all the elements of the specified collection to the end of the list.

These methods provide flexibility in inserting elements at specific positions and adding collections to lists.

The ArrayList class in Java dynamically grows its size by increasing its internal array capacity as needed. When elements are added and the current capacity is reached, a new array with a larger size is created, and all existing elements are copied to the new array. This process is known as "resizing".

Internally, ArrayList uses an array to store elements. The initial capacity is set when the ArrayList is created. When elements are added and the current size exceeds the capacity, the capacity is increased (often doubled) to accommodate more elements. This resizing operation ensures that the ArrayList can efficiently handle a dynamic number of elements.

Composition is favored over inheritance due to its flexibility and reusability. Inheritance can lead to tight coupling, making code more rigid and less adaptable to changes. Composition allows for a more modular and loosely coupled design, enabling easier maintenance and extension of code.

The '>>' operator is a signed right shift operator that preserves the sign bit, filling the vacant positions with the sign bit. The '>>>' operator is an unsigned right shift operator that fills the vacant positions with zeros, irrespective of the sign bit.

Composition and Aggregation are both forms of object association in OOP. Composition implies a strong relationship where one object is part of another and has no independent existence. Aggregation implies a weaker relationship where objects can exist independently.

Using new() creates a new String object on the heap, regardless of whether a similar String already exists. Using a literal creates a String in the String Pool, and if an identical String already exists, it is reused, promoting memory efficiency.

The 'new' operator is used to create an instance of a class at compile-time. 'newInstance()' is a method of the 'Class' class and is used to create an instance of a class at runtime. It provides more flexibility but is less type-safe compared to 'new'.

Yes, a program can still exceed its memory limit even with a garbage collector. Garbage collectors manage memory for objects that are no longer in use, but they cannot prevent memory leaks caused by objects that are unintentionally kept in memory due to lingering references.

Synchronization is necessary to ensure thread safety and prevent data corruption in concurrent programming. For example, in a multi-threaded environment, if two threads concurrently modify a shared variable without synchronization, it can lead to unpredictable results, and synchronization prevents such issues.

Java

public class Singleton {
private static final Singleton instance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return instance;
}
}

This code implements the Singleton design pattern, ensuring that only one instance of the 'Singleton' class is created. The instance is created eagerly during class loading, and the 'getInstance()' method always returns the same instance.

Java
public class Example {
public static void main(String[] args) {
int x = 5;
int y = 2;
System.out.println(x / y);
}
}

Output: 2
Steps: Declare and initialize variables 'x' and 'y', perform integer division, and print the result.

System.out.println() is a Java statement used to print a line of text to the standard output (usually the console). It automatically appends a newline character, facilitating easy display of information during program execution.

The Java thread lifecycle consists of several states:

• New: Before a thread is initiated but remains inactive.
• Runnable: When the thread is ready to run and waiting for CPU time.
• Blocked: When the thread is waiting for a monitor lock to enter a synchronized block or method.
• Waiting: When the thread is waiting indefinitely for another thread to perform a particular action.
• Timed Waiting: Similar to waiting, but with a specified maximum waiting time.
• Terminated: When the thread has completed its execution or terminated prematurely.

An unordered array allows for faster insertion and deletion but lacks efficient searching. An ordered array facilitates binary search but slows down insertions and deletions due to the need to maintain order. The choice depends on the specific requirements of the application.

Yes, it is permissible to import the same class or package twice in Java. The compiler ignores duplicate imports. There are no direct runtime implications, but it can lead to increased compilation time and potential confusion in the code.

Importing the main package does not automatically import its sub-packages in Java. To use classes from a sub-package, they must be explicitly imported. Importing 'com.myMainPackage.' does not import classes from 'com.myMainPackage.mySubPackage.'.

No, the finally block will not be executed if the try block concludes with System.exit(0). The 'System.exit()' method terminates the Java Virtual Machine, preventing the execution of any subsequent code, including the finally block.

Marker interfaces in Java are interfaces with no methods. They act as a tag to convey some information to the compiler or runtime environment. Examples include the 'Serializable' and 'Cloneable' interfaces, indicating that classes implementing them support serialization and cloning, respectively.

Double Brace Initialization is a technique in Java where an anonymous inner class is used to initialize an instance of a class with a block of code inside double braces. It's often used for creating and initializing collections in a concise manner.

Java

List<String> myList = new ArrayList<String>() {{
add("Item1");
add("Item2");
}};

The 'length()' method of the String class returns the number of characters in the string. However, if the string contains Unicode supplementary characters (those with code points above U+FFFF), each supplementary character counts as two characters in the length. Hence, for strings with supplementary characters, 'length()' may not accurately represent the visible length.

Java

public class OutputExample {
public static void main(String[] args) {
String str1 = "Hello";
String str2 = new String("Hello");
System.out.println(str1 == str2);
System.out.println(str1.equals(str2));
}
}

Output:
arduino
false
True

Explanation:

1. System.out.println(str1 == str2);
   This prints false because it compares the references of the two strings. str1 is created using string literal and is stored in the string pool, while str2 is explicitly created using the new keyword, resulting in a new object on the heap. Thus, they refer to different objects, and == checks for reference equality.
2. System.out.println(str1.equals(str2));
   This prints true because the equals() method compares the content of the strings. Both str1 and str2 have the same sequence of characters ("Hello"), so the equals() method returns true. This demonstrates the importance of using equals() for content comparison, especially when dealing with objects.

Objects qualify for garbage collection once they are no longer accessible. This can happen through:

• Setting references to null.
• Reassigning references.
• Exiting the scope of local variables.
• Clearing references from collections.
• Objects in the String Pool becoming unreachable.

Java
public class GCExample {
public static void main(String[] args) {
String s1 = new String("Hello");
String s2 = new String("World");
s1 = null;
String s3 = s2;
s2 = null;
}
}

In this program, two objects become eligible for garbage collection: the first String object created with "Hello" and the second String object created with "World". After setting s1 and s2 to null, they are no longer reachable.

The Dependency Injection (DI) method is recommended for introducing dependencies. DI involves injecting dependencies from the outside, typically through constructor injection or setter injection. This promotes loose coupling, making the code more modular, maintainable, and testable.

In Spring, the scope of a bean is defined using the scope attribute in the bean configuration. The available scopes include:

• Singleton: The default scope, creating a single instance per Spring container.
• Prototype: Creating a new instance each time the bean is requested.
• Request: Creating a new instance for each HTTP request (valid in a web-aware Spring context).
• Session: Creating a new instance for each HTTP session (valid in a web-aware Spring context).
• Global Session: Similar to session scope but for global HTTP sessions (valid in a web-aware Spring context).
• Custom Scopes: Users can define custom scopes as needed.

A Memory Leak occurs when a program allocates memory for objects but fails to release or deallocate them properly. Common causes include:

• Unintentional object retention, preventing garbage collection.
• Cyclic references where objects reference each other, creating a loop.
• Static references that persist throughout the program's lifecycle.
• Improper use of data structures leading to unintended object retention.
• Unclosed resources, such as files or network connections.

No, invoking the sleep() method on a thread does not release the lock it holds. The thread retains the lock while in the sleeping state. The sleep() method only pauses the execution of the current thread for a specified duration without affecting its acquired locks. Locks are released when the synchronized block or method is exited or when an exception occurs inside the block.