Infosys 3 Years Java Experience | Java | Spring Boot | Microservices | Selected

Summary

This technical interview focuses on assessing the candidate’s proficiency in Java, Spring Boot, microservices, and databases. The candidate demonstrates solid understanding of key Java concepts like garbage collection, dynamic binding, and thread management. They also provide clear insights into Spring Boot application development, database connectivity, and handling transactions. Microservices architecture is discussed, highlighting its benefits over monolithic systems. The candidate showcases knowledge of collections, HashMap operations, and database management techniques like indexing, foreign keys, and primary keys. The interview reveals a well-rounded developer familiar with both backend and application monitoring best practices.

Takeaways

• 😀 The candidate has strong experience in Java, Spring Boot, microservices, and Oracle Database, working in the supply chain domain.
• 😀 Garbage collection in Java is used to remove unused objects from memory to optimize resource usage.
• 😀 Dynamic binding in Java allows method calls to be resolved at runtime, enabling polymorphism between parent and child classes.
• 😀 Strings in Java are immutable, and modifications create new string objects; StringBuilder or StringBuffer can be used for repeated concatenations.
• 😀 Threads in Java can be created by extending the Thread class or implementing Runnable, with key thread states being new, runnable, running, waiting/blocked, and terminated.
• 😀 The candidate has practical knowledge of Java collections, including ArrayList, LinkedList, HashMap, and understands the difference between normal and concurrent hash maps.
• 😀 Spring Boot applications connect to databases via dependencies, configuration in application.properties, and repository interfaces like JpaRepository or CrudRepository.
• 😀 REST API design in Spring Boot involves a controller layer for endpoints, a service layer for business logic, and a DAO layer for database operations.
• 😀 Microservices offer advantages over monolithic applications, including independent deployment, easier debugging, and reduced impact from changes in individual services.
• 😀 Database knowledge includes understanding primary keys, foreign keys, and indexes for performance, but the candidate was unsure about normalization concepts.
• 😀 Application monitoring in Spring Boot can be implemented using Actuator or Spring Boot Admin, and deployments typically involve embedded servers or organizational servers like Liberty.

Q & A

What is garbage collection in Java and how does it work?

Garbage collection in Java is the process of automatically reclaiming memory by removing unused objects. When an object is no longer referenced, the garbage collector frees the memory allocated to that object. This helps prevent memory leaks by ensuring unused objects are cleaned up efficiently.

What is dynamic binding in Java, and how does it work with method overriding?

Dynamic binding in Java refers to the ability of the JVM to determine at runtime which method to invoke. This is related to method overriding, where a subclass provides its own implementation of a method defined in its superclass. The decision on which method to call is made at runtime, depending on the object type (parent or child) being referenced.

How are strings handled in Java, and what does it mean that they are immutable?

In Java, strings are immutable, meaning that once a string object is created, its value cannot be changed. If you attempt to modify a string, a new string object is created, and the original string remains unchanged. This ensures that string objects are thread-safe and cannot be altered inadvertently.

What is the difference between `StringBuilder` and `StringBuffer` in Java?

`StringBuilder` and `StringBuffer` both allow the modification of strings, but the key difference lies in thread safety. `StringBuffer` is synchronized, making it thread-safe but potentially slower in multi-threaded environments. `StringBuilder` is not synchronized, which makes it faster but not thread-safe.

How do you create a thread in Java? What are the two common ways to do this?

In Java, a thread can be created by either extending the `Thread` class or implementing the `Runnable` interface. Extending `Thread` allows you to override the `run()` method, while implementing `Runnable` requires implementing the `run()` method and passing the `Runnable` object to a `Thread` instance.

Can you explain the different thread states in Java?

In Java, a thread can go through several states: 1. **New**: The thread is created but not yet started. 2. **Runnable**: The thread is ready to run but waiting for CPU time. 3. **Blocked/Waiting**: The thread is waiting for resources or a condition to be met. 4. **Terminated**: The thread has completed its task and is no longer running.

What is the purpose of `HashMap` in Java, and how does it store data?

`HashMap` is a collection that stores data in key-value pairs. It uses a hashing technique to store the data, where a hash function maps keys to specific locations (buckets) in the map, allowing for quick retrieval and modification of values based on their corresponding keys.

When should you use `ConcurrentHashMap` instead of `HashMap` in Java?

`ConcurrentHashMap` should be used when multiple threads will be accessing and modifying the map concurrently. Unlike `HashMap`, which is not thread-safe, `ConcurrentHashMap` provides thread-safe operations by dividing the map into segments, allowing multiple threads to operate on different segments without conflict.

How does Spring Boot handle database connections?

In Spring Boot, to connect to a database, you need to add the necessary database dependencies in the `pom.xml` file, specify the connection details (URL, username, password, driver) in the `application.properties` file, and use repositories like `JpaRepository` or `CrudRepository` for database operations. Spring Boot simplifies this process with its auto-configuration features.

What are the key steps to building a REST API in Spring Boot?

To build a REST API in Spring Boot, you need to define a controller class with `@RestController` annotation and create methods to handle different HTTP requests (GET, POST, etc.). You then define a service layer to handle business logic and a repository layer to interact with the database. Spring Boot’s auto-configuration makes it easy to expose these services as REST APIs.