Question 1

What are the core principles of Object-Oriented Programming (OOP)?

Accepted Answer

The four core principles of OOP are:
1. Encapsulation: Hiding data fields and exposing them through getter/setter methods.
2. Inheritance: Creating parent-child relationships between classes to reuse code.
3. Polymorphism: Allowing methods to take different forms (Method Overloading and Method Overriding).
4. Abstraction: Hiding internal implementation details using interfaces and abstract classes.

Question 2

What is Spring Boot, and how does it differ from the Spring Framework?

Accepted Answer

Spring is a Java application framework providing dependency injection and core components. Spring Boot is an extension of Spring that makes it easy to create stand-alone, production-ready applications. It simplifies development by providing:
1. Auto-configuration: Automatically configures beans based on classpath dependencies.
2. Starters: Pre-packaged dependency bundles.
3. Embedded Server: Built-in Tomcat/Jetty, avoiding standalone WAR deployments.

Question 3

Explain Dependency Injection (DI) and Inversion of Control (IoC).

Accepted Answer

Inversion of Control (IoC) is a design principle where the control of object creation and lifecycle is transferred from the program code to a container. Dependency Injection (DI) is a specific implementation of IoC where dependencies are dynamically injected into a class (via Constructor, Setter, or Field) by the Spring IoC container.
Code Example:
@Component
public class Car {
    private Engine engine;

// Constructor injection (Preferred)
    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }
}

Question 4

What are the different ways to inject dependencies in Spring?

Accepted Answer

1. Constructor Injection: Dependencies are passed through the constructor. Safe for immutable fields, preferred for required dependencies.
2. Setter Injection: Dependencies are passed via setter methods. Useful for optional dependencies.
3. Field Injection: Directly annotating variables with `@Autowired`. Easy to write, but makes testing harder and violates encapsulation.

Question 5

What is Spring Boot Auto-configuration, and how does it work?

Accepted Answer

Auto-configuration automatically configures Spring beans based on the libraries present on the project classpath. It is enabled by the `@EnableAutoConfiguration` annotation (included in `@SpringBootApplication`). It reads configuration targets from meta-files inside jar dependencies and registers matches dynamically.
Code Example:
@SpringBootApplication // Includes @Configuration, @EnableAutoConfiguration, and @ComponentScan
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Question 6

What is Spring Boot Actuator?

Accepted Answer

Spring Boot Actuator provides production-ready monitoring and management endpoints for your application. It lets you audit application health (`/actuator/health`), check system metrics (`/actuator/metrics`), examine environment configurations (`/actuator/env`), and inspect thread dumps.

Question 7

What is the difference between `@Component`, `@Service`, and `@Repository` annotations?

Accepted Answer

`@Component` is a generic stereotype annotation indicating that a class is a Spring-managed bean. `@Service` and `@Repository` are specialized components. `@Service` designates business logic layers. `@Repository` designates database access layers, automatically translating SQL exceptions into Spring's DataAccessException hierarchy.

Question 8

Explain Spring Bean Scopes.

Accepted Answer

Spring beans can be configured with different scopes:
1. Singleton (Default): A single shared bean instance is created per IoC container.
2. Prototype: A new bean instance is created every time it is requested.
3. Request: A bean instance is created per HTTP request (Web apps).
4. Session: A bean instance is created per HTTP session (Web apps).

Question 9

What is Hibernate, and how does it relate to JPA?

Accepted Answer

JPA (Java Persistence API) is a specification or set of guidelines that defines how to map Java objects to relational database tables (ORM). Hibernate is a popular implementation framework that implements the JPA specifications.

Question 10

What is the difference between `@RestController` and `@Controller`?

Accepted Answer

`@Controller` is used to create traditional MVC controllers that return view templates (HTML/JSP). `@RestController` is a convenience annotation that combines `@Controller` and `@ResponseBody`, ensuring that method return values are automatically serialized into JSON/XML payloads directly in the HTTP response body.

Question 11

What is the Spring Boot Starter?

Accepted Answer

Spring Boot Starters are a set of convenient dependency descriptors that you can include in your application. They contain pre-configured dependency descriptors (e.g. `spring-boot-starter-web` includes Tomcat, Jackson, and Spring Web MVC) to bootstrap configurations.

Question 12

How do you handle exceptions globally in Spring Boot?

Accepted Answer

You handle exceptions globally using `@ControllerAdvice` or `@RestControllerAdvice` along with `@ExceptionHandler` annotations on methods. This separates exception mapping from controllers. Code Example: @RestControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(UserNotFoundException.class) public ResponseEntity handleUserNotFound(UserNotFoundException ex) { return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND); } }

Question 13

Explain Lazy Loading vs Eager Loading in Hibernate/JPA.

Accepted Answer

Eager Loading fetches associated entities immediately along with the parent entity (using SQL JOINS). Lazy Loading delays the fetching of associated entities until they are accessed for the first time in code. Eager is default for `@OneToOne` and `@ManyToOne`, while Lazy is default for `@OneToMany` and `@ManyToMany`.

Question 14

What is the N+1 select problem in Hibernate, and how do you resolve it?

Accepted Answer

The N+1 problem occurs when you fetch a parent entity and then fetch its child collections. Hibernate executes 1 query to fetch all parents, and then N queries to fetch children for each parent. It is resolved using Join Fetching (`JOIN FETCH` in JPQL) or Entity Graphs to fetch both in a single query.
Code Example:
// Resolving N+1 with JOIN FETCH
@Query("SELECT u FROM User u JOIN FETCH u.orders")
List<User> findAllUsersWithOrders();

Question 15

Explain the garbage collection process in Java.

Accepted Answer

JVM heap memory is divided into Young Generation (Eden space, Survivor spaces S0/S1) and Old Generation. New objects are created in Eden. Minor GC cleans Young Gen, moving surviving objects to Survivor spaces, and eventually promoting long-lived objects to Old Gen. Major/Full GC cleans Old Gen. Common GC algorithms include G1, ZGC, and CMS.

Question 16

What is the difference between `HashMap` and `ConcurrentHashMap` in Java?

Accepted Answer

`HashMap` is not synchronized and is not thread-safe. `ConcurrentHashMap` is thread-safe and highly concurrent. Instead of locking the entire map (like HashTable), it locks at a segment or bucket level (using CAS and fine-grained locks), allowing multiple threads to read and write concurrently.

Question 17

Explain Spring AOP (Aspect-Oriented Programming).

Accepted Answer

AOP enables modularizing cross-cutting concerns (like logging, security, or transaction management) that span multiple classes. You define 'Aspects' (classes containing cross-cutting code) and 'Points' (where the aspect should run), which are woven into target classes by Spring proxies.
Code Example:
@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore() {
        System.out.println("Method execution started");
    }
}

Question 18

What is the use of the `@Transactional` annotation?

Accepted Answer

`@Transactional` is used to configure transaction boundaries. It ensures that all database operations within the method run inside a transaction database context. If any database exception is thrown, Spring rolls back all operations; otherwise, commits them.

Question 19

What is the Spring Cloud, and when is it used?

Accepted Answer

Spring Cloud provides tools for developers to build common patterns in distributed systems (microservices). Common components include Spring Cloud Config Server (centralized configuration), Eureka (service discovery), Gateway (routing/filter APIs), and Resistence/Hystrix (circuit breakers).

Question 20

Explain the Java 8 Stream API.

Accepted Answer

The Stream API allows processing of collections in a declarative, functional manner. You construct pipelines with intermediate operations (like `filter`, `map`) and terminal operations (like `collect`, `forEach`).
Code Example:
List<String> names = list.stream()
    .filter(s -> s.startsWith("A"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

Java & Spring Boot Interview

Difficulty Filters

Tools & Options

What are the core principles of Object-Oriented Programming (OOP)?

What is Spring Boot, and how does it differ from the Spring Framework?

Explain Dependency Injection (DI) and Inversion of Control (IoC).

What are the different ways to inject dependencies in Spring?

What is Spring Boot Auto-configuration, and how does it work?

What is Spring Boot Actuator?

What is the difference between `@Component`, `@Service`, and `@Repository` annotations?

Explain Spring Bean Scopes.

What is Hibernate, and how does it relate to JPA?

What is the difference between `@RestController` and `@Controller`?

What is the Spring Boot Starter?

How do you handle exceptions globally in Spring Boot?

Explain Lazy Loading vs Eager Loading in Hibernate/JPA.

What is the N+1 select problem in Hibernate, and how do you resolve it?

Explain the garbage collection process in Java.

What is the difference between `HashMap` and `ConcurrentHashMap` in Java?

Explain Spring AOP (Aspect-Oriented Programming).

What is the use of the `@Transactional` annotation?

What is the Spring Cloud, and when is it used?

Explain the Java 8 Stream API.

Technical Interview Mastery Blueprint

1. The Engineering STAR Technique

2. Defending Architectural Trade-Offs

3. Clean Code & Edge-Case Proactivity

4. Antipatterns to Avoid

Explore Related Tools

Javascript Interview

Ai Ml Interview

Ai Theory Interview

Angular Interview Questions

Artificial Intelligence Interview

Aws Interview Questions

Follow Us

Our Tools

Our Company

Special Tools