Java Interview Questions Overview
Uploaded by
S.S. AmmarJava Interview Questions Overview
Uploaded by
S.S. Ammar- Frequently Asked Interview Questions
Common questions
Powered by AISpring Boot simplifies application development by providing defaults for common configuration settings, thus eliminating the need for extensive XML configuration typical in traditional Spring applications. It offers embedded servers to reduce deployment complexity, auto-configuration to automatically set up Spring applications based on the included libraries, and 'starter' dependencies to simplify dependency management . These features enhance developer productivity and accelerate application bootstrapping by minimizing setup and configuration overhead, allowing developers to focus more on functionality than configuration .
Functional interfaces in Java 8 are interfaces with a single abstract method, providing a target for lambda expressions which enhance their utility by offering a clear and concise syntax to express instances of these interfaces. This leads to more readable and maintainable code. Lambda expressions eliminate the need for anonymous class implementations, promote the use of high-order functions, and enable the convenience of behavior parameterization . They simplify the implementation of instances, allowing focus on the behavior rather than the boilerplate code.
Lazy loading is preferable when you have large datasets you don't want to load completely at once for performance reasons. It allows for on-demand initialization of objects to conserve memory and improve initial load times . Eager loading is suited for smaller datasets where accessing the data immediately after loading the object is critical to ensure availability and minimize repeated queries. Lazy loading reduces memory footprint but increases runtime complexity by repeatedly querying the database, while eager loading might lead to redundant data retrieval and increased initial load time .
The equals() method determines if another object is "equal" to this one. The hashCode() method provides a unique integer representing the object instance and is used for bucketing in hash algorithms. Consistent overriding is crucial because if two objects are equal as per equals(), they must return the same hashCode() to ensure the objects function correctly in hash-based collections like HashMap. Inconsistent implementation can lead to the logical contradiction where equal objects inhabit different buckets .
String immutability in Java is beneficial, especially in multi-threaded environments, primarily because it ensures thread safety. As strings cannot change after creation, they can be shared across multiple threads without synchronization, reducing the overhead of locking mechanisms. The immutability also optimizes memory usage by enabling the String Pool, where identical strings share a single storage location . This leads to a reduction in memory footprint and improves performance.
An abstract class can have member variables and defined methods, whereas interfaces can only have constants (variables are implicitly 'public static final') and abstract methods (before Java 8). You choose an abstract class when you need a common base class with shared code, but use an interface to define a contract for classes to implement, enabling multiple inheritance . Choose interfaces when multiple inheritance and unrelated class sharing a contract is needed, and abstract classes for common base class functionality.
HashMap is non-synchronized and allows null values and keys, designed for single-threaded scenarios while ConcurrentHashMap is synchronized for concurrent use, preventing null keys and values . ConcurrentHashMap enhances performance in concurrent applications by allowing concurrent reads and simultaneous writes in a segment-based manner, reducing contention. Its segmented locks lead to higher throughput and reduced overhead compared to synchronized maps where a complete lock serializes access .
Polymorphism enhances flexibility and maintainability by allowing objects to be treated as instances of their parent class. This decouples the code specifics from the code dynamics, allowing changes in object implementations without altering the system’s behavior. Using polymorphism, new types can be introduced into the system with minimal changes to existing code. It facilitates a single interface to interact with different types and encourages method overriding, allowing dynamic method resolution at runtime .
Encapsulation in object-oriented programming allows for restricting access to certain components of an object and bundling data and methods that work on the data within a single unit or class. This design principle contributes to robust software design by protecting object integrity and hiding the internal implementation details, only exposing a controlled interface. Object interaction is well-defined and less dependency on changes in other parts of the program are ensured, thus leading to a more maintainable codebase .
The @Transactional annotation simplifies transaction management by abstracting boilerplate code required for starting, committing, and rolling back transactions. Unlike traditional manual management that requires explicit coding of transaction boundaries, @Transactional allows these activities to be handled declaratively, enhancing readability and reducing error chances in complex transaction scripts . It promotes cleaner code and easier maintenance by centralizing transaction policy within configuration and metadata rather than code logic, enabling flexibility in transaction management policies without extensive code alterations .
