OOPs

What are the concepts related to Object Oriented Programming?

Core Principles

Encapsulation: Hiding implementation details, bundling data with methods
Inheritance: Creating new classes from existing ones
Polymorphism: Objects behaving differently based on context
Abstraction: Simplifying complex systems by modeling classes

Key OOP Components

Classes & Objects: Blueprints and their instances
Constructors: Special methods for initialization
Method Overloading: Same method name, different parameters
Method Overriding: Replacing inherited method implementation
Interfaces: Contracts specifying behavior
Abstract Classes: Partial implementations, cannot be instantiated

Relationships

Association: Object references another independent object
Aggregation: “Has-a” relationship, weak ownership
Composition: Strong ownership, contained object cannot exist independently

How many ways can an object be created in Java?

Using new keyword

MyClass obj = new MyClass();

Using Class.newInstance()

MyClass obj = MyClass.class.newInstance();

Using clone() method

MyClass obj2 = (MyClass)obj1.clone();

What’s the difference between abstract class and interface?

“Abstract classes and interfaces serve different purposes. Abstract classes provide a partial implementation with some concrete methods — you’d use them when classes share functionality in an ‘is-a’ relationship. They support single inheritance.

Interfaces, on the other hand, define a contract of what a class can do without implementation details. They enable multiple inheritance through the ‘implements’ keyword.

In practice, I’d use an abstract class when creating a common base like ‘Vehicle’ with shared functionality, but an interface for capabilities like ‘Drivable’ that can apply across different hierarchies.”

When should we use an interface and when should we use an abstract class?

“I choose an abstract class when I have a clear ‘is-a’ relationship with shared code. For example, if I’m building shapes like Circle and Rectangle that share calculation methods but with different implementations, I’d create an abstract Shape class with some concrete utility methods.

I use interfaces when I need to define a capability that cuts across different hierarchies. If I need classes like Car, Boat, and Plane to all be ‘Drivable’ despite having different inheritance trees, an interface is perfect.

Along with these OOPS Question you should go through this as well,

Object-Oriented Programming Concepts For Every Developer

Core Java

How many objects will be created using a string literal?

When creating a string using a string literal:

String s = “hello”;

Only 1 object is created in the String pool (if that string doesn’t already exist in the pool)

For identical string literals:

String s1 = “hello”;

Still only 1 object is created in the String pool that both variables reference

For comparison, using the new operator:

String s3 = new String(“hello”);

Creates 1–2 objects: one in heap and possibly one in String pool (if not already there)

Why does Java have two ways of creating strings (literal vs new keyword)?

String Literals

String s = “hello”;

Memory Efficiency: Uses String pool (a special memory area)
String Interning: Identical literals share same memory location
Performance: Better for repeated strings
Using new Keyword

String s = new String(“hello”);

Forced New Object: Always creates object in heap (regardless of pool)
Different Identity: == comparison with identical pool strings returns false
Control: When distinct objects are needed

What makes a class mutable or immutable?

Immutable Class Characteristics

Final class: Cannot be extended
Final fields: All fields private and final
No setters: No methods that modify state
Defensive copying: Safe handling of mutable field objects
Complete initialization: All fields set in constructor

Mutable Class Characteristics

Modifiable state: Internal state can change after creation
Setter methods: Methods that modify internal fields
Non-final fields: Fields can be reassigned

Examples

Immutable: String, Integer, LocalDate
Mutable: StringBuilder, ArrayList, Date

Immutability provides thread safety, simplifies concurrent programming, and enables safe sharing of objects across components.

What are the Marker Interfaces?

Marker interfaces are empty interfaces (no methods) that “mark” a class as having a certain property.

Common Examples

Serializable

Marks a class as capable of being serialized/deserialized

Cloneable

Indicates a class can be legally cloned via Object.clone()

Remote

Marks objects that can be accessed from another JVM (RMI)

RandomAccess

Tags List implementations that support efficient random access

EventListener

Base interface for all event listener interfaces

What’s the difference between throw and throws?

throw actively throws exceptions, while throws declares which exceptions might be thrown.

Can we use only a try block without catch or finally?

Before Java 7: No, a try block must be accompanied by either a catch block or a finally block (or both).

Since Java 7: Yes, but only with try-with-resources:

try (FileInputStream fis = new FileInputStream(“file.txt”)) {

// Code that uses the resource

// Resource automatically closed when block exits

}

Can we use multiple catch blocks?

Yes, Java supports multiple catch blocks:

What is the purpose of the finally block?

The finally block serves several critical purposes:

Guaranteed execution: Executes regardless of whether an exception occurs or not
Resource cleanup: Ideal place to close resources (files, connections, streams)
Exception-independent code: Runs even if try/catch blocks have return statements
Transaction completion: Ensures cleanup operations happen no matter what

What are the main interfaces/classes in the Collection framework?

“The Collection framework has several key interfaces. At the top is Collection, which branches into three main interfaces: List for ordered collections, Set for unique elements, and Queue for FIFO operations.

For List, we commonly use ArrayList for fast access and LinkedList for efficient insertions.

With Sets, HashSet offers the fastest operations, TreeSet keeps elements sorted, and LinkedHashSet maintains insertion order.

The Map interface stands separate from Collection and stores key-value pairs. HashMap provides fast lookups, TreeMap keeps keys sorted, and LinkedHashMap preserves insertion order.

What is the contract of equals() and hashCode()?

“The equals-hashCode contract has two key rules: First, if two objects are equal according to equals(), they must have the same hashCode(). Second, if two objects have the same hashCode(), they aren’t necessarily equal.

This contract is crucial for hash-based collections like HashMap. When you put an object in a HashMap, it uses hashCode() to determine the bucket, then equals() to find the exact match.

If you override equals() but not hashCode(), two equal objects might land in different buckets, making your HashMap behave unpredictably. You’d search for your object and get null, even though it’s there!

Internal working of HashMap?

“HashMap uses an array of buckets, each containing entries. The process starts with the key’s hashCode() which is transformed to determine the bucket index.

When you put(key, value), the system calculates the bucket index from the key’s hash, then either creates a new entry or updates an existing one if the key already exists.

For collisions — when different keys map to the same bucket — HashMap uses linked lists to store multiple entries. In Java 8, if a bucket exceeds 8 entries, it converts the linked list to a red-black tree for O(log n) instead of O(n) performance.

The load factor determines when the HashMap resizes. Default is 0.75, meaning when the map is 75% full, it doubles in size and rehashes all entries.

Get operations follow the same process — hash the key, find the bucket, then search the list/tree for the matching key using equals().

This gives HashMap O(1) performance for most operations, though it can degrade with many collisions.”

On what basis does HashMap decide where to store an element?

“HashMap decides where to store an element based on the key’s hashCode() method. The process works like this:

When you put(key, value), HashMap first calls key.hashCode() to get an integer. It then applies a bit manipulation function to distribute the values better.

Next, it uses this processed hash value modulo the array length to determine the exact bucket index: index = hash & (array.length — 1).

This is why proper hashCode() implementation is critical — it directly determines where your object gets stored. If two different keys produce the same index (a collision), HashMap stores both entries in the same bucket using a linked list or tree structure.

In a real-world example, if you use custom objects as keys without proper hashCode(), you might find your HashMap performing poorly with many collisions or failing to retrieve objects you know you’ve stored.”

Is hashing based on key, value, or both?

“Hashing in HashMap is based exclusively on the key. The value plays no role whatsoever in determining the bucket location. Only the key’s hashCode() matters for storage and retrieval. The value is simply the payload stored at the location determined by the key.”

If we insert the same key in HashMap, what happens to the previous value?

“The previous value is overwritten. HashMap maintains unique keys, so inserting with an existing key replaces the old value with the new one.”

What’s the difference between Comparable and Comparator? When to use each?

“Comparable is implemented by the class itself with compareTo() for natural ordering. Comparator is a separate class with compare() for custom sorting.

Use Comparable when a class has an intrinsic order (like String). Use Comparator when you need multiple sort options or can’t modify the original class.”What are Fail-Fast and Fail-Safe iterators?

Why Fail-Safe not throw exceptions?

“Fail-safe iterators work on a clone of the original collection, not the collection itself. Since modifications affect the original collection and not the copy being iterated, there’s no way to detect concurrent modifications. Examples include iterators from ConcurrentHashMap and CopyOnWriteArrayList. The trade-off is they may not reflect the latest state of the collection.”

How to make an ArrayList read-only?

“Use Collections.unmodifiableList(arrayList) to create a read-only view. Any modification attempts will throw UnsupportedOperationException. Note that the original list can still be modified, which will affect the unmodifiable view.”

Java 8 / Stream API

What’s the difference between Collection and Stream?

“Collections store elements while Streams process them. Collections are mutable data structures that hold all elements in memory, can be traversed multiple times, and use eager evaluation.

Streams are pipelines for data processing, not storage. They use lazy evaluation, can process data in parallel easily, are traversed only once, and excel at functional operations like map/filter/reduce. Use Collections for data storage and manipulation, Streams for data processing operations.”

If Stream modifies the data using filter/map, isn’t that a modification?

“Stream operations don’t modify the original data source. They create new values in the pipeline while leaving the source untouched. The operations define transformations, not modifications.”

What are the new features in Java 8?

Left Blank Intentionally

What are intermediate and terminal operations in streams?

“Intermediate operations (like filter, map) return another stream and are lazy — they don’t execute until needed.

Terminal operations (like collect, forEach, reduce) trigger actual execution, produce a result, and end the stream. You can chain multiple intermediate operations, but only one terminal operation concludes the pipeline.”

How to use filter() and map(), give an example?

Filter selects elements based on a condition; map transforms each element.”

List<String> names = Arrays.asList("Tom", "Richard", "Harry");

List<String> result = names.stream()
    .filter(name -> name.length() > 3)     // keeps only longer names
    .map(String::toUpperCase)              // converts to uppercase
    .collect(Collectors.toList());         // collects to new list

// result: [RICHARD, HARRY]

How to declare a list of integers in Java?

// Empty ArrayList
List<Integer> list1 = new ArrayList<>();

// ArrayList with initial elements
List<Integer> list2 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

// Fixed-size list from Arrays utility
List<Integer> list3 = Arrays.asList(1, 2, 3, 4, 5);

// Immutable list (Java 9+)
List<Integer> list4 = List.of(1, 2, 3, 4, 5);

// ArrayList with initial capacity
List<Integer> list5 = new ArrayList<>(20);

// Using diamond operator (Java 7+)
ArrayList<Integer> list6 = new ArrayList<>();

How to reverse a list using Java 8 Stream API?

List<Integer> original = Arrays.asList(1, 2, 3, 4, 5);

// Using IntStream to reverse the list
List<Integer> reversed = IntStream.range(0, original.size())
    .map(i -> original.size() - 1 - i)
    .mapToObj(original::get)
    .collect(Collectors.toList());

// Alternative approach
List<Integer> reversed2 = original.stream()
    .collect(Collectors.toCollection(LinkedList::new))
    .descendingIterator()
    .forEachRemaining(new ArrayList<>()::add);

How to sort a list using Java 8?

List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);

// Using List.sort() with natural ordering
numbers.sort(Comparator.naturalOrder());

// Using List.sort() with reverse order
numbers.sort(Comparator.reverseOrder());

// Using stream for natural ordering
List<Integer> sorted = numbers.stream()
    .sorted()
    .collect(Collectors.toList());

// Using stream with custom comparator
List<String> names = Arrays.asList("Alex", "Charlie", "Bob");
List<String> sortedByLength = names.stream()
    .sorted(Comparator.comparing(String::length))
    .collect(Collectors.toList());

// Parallel sorting for large lists
numbers.parallelStream()
    .sorted()
    .collect(Collectors.toList());

Do we have an intermediate method in Java 8 to sort a list?

// Yes, the sorted() method is an intermediate operation in Stream API

// Natural ordering
List<Integer> sortedNumbers = numbers.stream()
    .sorted()              // intermediate operation
    .collect(Collectors.toList());  // terminal operation

// With custom comparator
List<String> sortedNames = names.stream()
    .sorted(Comparator.comparing(String::length))  // intermediate
    .collect(Collectors.toList());  // terminal

How to find even numbers from a list?

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// Using Stream API filter
List<Integer> evenNumbers = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());
// Result: [2, 4, 6, 8, 10]

// Alternative with method reference (less common)
List<Integer> evenNumbers2 = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

// For parallel processing of large lists
List<Integer> evenNumbersParallel = numbers.parallelStream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

How to square elements in a list and filter those greater than 25?

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

List<Integer> result = numbers.stream()
    .map(n -> n * n)                // Square each number
    .filter(n -> n > 25)            // Keep only those > 25
    .collect(Collectors.toList());  // Collect to a new list

// Result: [36, 49, 64, 81, 100]

What is a functional interface?

“A functional interface is an interface with exactly one abstract method. It can have any number of default or static methods, but must contain only a single abstract method.

Java 8 introduces the @FunctionalInterface annotation to explicitly declare this intent. These interfaces enable lambda expressions and method references.

Examples from java.util.function include:

Predicate<T>: test()
Consumer<T>: accept()
Function<T,R>: apply()
Supplier<T>: get()

Additional Reading on Java 8

Design Principles / Patterns

What are the SOLID principles?

“SOLID principles are object-oriented design guidelines:

Single Responsibility: A class should have only one reason to change, handling just one job.
Open/Closed: Classes should be open for extension but closed for modification. Add functionality by extending, not changing existing code.
Liskov Substitution: Subtypes must be substitutable for their base types without altering program correctness.
Interface Segregation: Clients shouldn’t depend on interfaces they don’t use. Prefer many specific interfaces over one general-purpose interface.
Dependency Inversion: High-level modules shouldn’t depend on low-level modules. Both should depend on abstractions. Depend on interfaces, not concrete implementations.”

What is the Factory Design Pattern?

“The Factory Pattern is a creational design pattern that provides an interface for creating objects without specifying their concrete classes.

A Factory class contains a method that returns different types of objects based on input parameters or configuration.

Benefits: Centralizes object creation, hides implementation details, and makes code more maintainable when adding new product types.”

What is Singleton? How to break Singleton?

“Singleton ensures a class has only one instance with a global access point.

Ways to break Singleton:

Reflection: Access private constructor

Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
Singleton instance2 = constructor.newInstance();

Multithreading

How to create a thread using Thread and Runnable?

// Using Thread class
Thread thread1 = new Thread() {
    @Override
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }
};
thread1.start();

// Using Runnable interface (preferred)
Runnable task = () -> System.out.println("Runnable running: " + Thread.currentThread().getName());
Thread thread2 = new Thread(task);
thread2.start();

// One-liner with Runnable
new Thread(() -> System.out.println("One-liner thread")).start();

// Using ExecutorService (modern approach)
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(() -> System.out.println("Executed in thread pool"));
executor.shutdown();

Which method is overridden in Runnable?

“The run() method is overridden in Runnable. The Runnable interface contains only one abstract method: void run(). This method contains the code that will be executed in a separate thread when the Thread.start() method is called."

What happens when a thread is started?

“When you call start() on a thread:

JVM allocates memory and resources for the new thread
Thread enters the ‘Runnable’ state (not necessarily executing immediately)
When scheduled by the JVM, the thread’s run() method executes in the new thread
The original thread continues execution independently
Once run() completes, the thread dies and resources are released

Calling start() twice on the same thread throws IllegalThreadStateException. Directly calling run() executes in the current thread, not a new one.”

Architecture / Messaging

What is event-driven architecture?

“Event-driven architecture is a design pattern where the flow is determined by events (state changes, user actions, messages).

Key components:

Event producers generate events
Event consumers respond to events
Event broker/bus routes events
Events are asynchronous and decoupled

In Java, this is implemented using:

Observer pattern
Listener interfaces
Message queues like Kafka/RabbitMQ
Frameworks like Spring Events, Vert.x

Benefits include loose coupling, scalability, and responsiveness. Challenges include debugging complexity and ensuring event order/consistency.”

What is the Producer-Consumer problem?

“The Producer-Consumer problem involves two types of processes sharing a fixed-size buffer:

Producers add data to the buffer
Consumers remove data from the buffer

Synchronization challenges:

Producers must wait if buffer is full
Consumers must wait if buffer is empty
Concurrent access must be controlled

Java solutions include:

Using wait()/notify() with synchronized blocks
BlockingQueue implementations like ArrayBlockingQueue
Semaphores to control access

BlockingQueue<Task> queue = new ArrayBlockingQueue<>(10);
// Producer
queue.put(new Task()); // Blocks if full
// Consumer
Task task = queue.take(); // Blocks if empty

Have you worked with Kafka or RabbitMQ?

Kafka is a distributed streaming platform focusing on high-throughput, fault-tolerance, and durability. It’s ideal for real-time data pipelines and streaming analytics, using a publish-subscribe model with persistent storage. Kafka excels at event sourcing and handling massive scale with its partitioned log architecture.

RabbitMQ is a traditional message broker implementing AMQP protocol. It offers more routing patterns (direct, topic, fanout) and focuses on message delivery guarantees. RabbitMQ is typically easier to set up and manage for standard messaging needs, with strong consistency guarantees.

The choice depends on requirements: Kafka for high-volume data streaming and analytics; RabbitMQ for traditional enterprise messaging patterns with complex routing needs.”

What is the use of API Gateway?

“An API Gateway serves as a single entry point for client requests to backend services, especially in microservices architecture. It handles:

Request routing to appropriate services
Authentication and authorization
Rate limiting and throttling
Protocol translation (e.g., REST to gRPC)
Response caching
Request/response transformation
Load balancing
Circuit breaking for failed services
API versioning
Analytics and monitoring

Popular implementations include Spring Cloud Gateway, Netflix Zuul, Kong, and AWS API Gateway. The gateway pattern simplifies client interactions by providing a unified API layer while hiding the complexity of the underlying service architecture.”

What is message-driven architecture?

“Message-driven architecture is a design where components communicate asynchronously via messages, rather than synchronous method calls.

Database / SQL

What do you mean by normalization?

“Normalization is the process of organizing data in a database to reduce redundancy and improve data integrity. It involves dividing large tables into smaller ones and defining relationships between them, following normal forms (1NF through 5NF) to eliminate duplications and anomalies.

Difference between TRUNCATE, DROP, and DELETE?

TRUNCATE vs DROP vs DELETE:

DELETE removes specific rows, logs each deletion, can be rolled back, and preserves table structure
TRUNCATE removes all rows quickly, doesn’t log individual deletions, resets identity counters, and can’t target specific rows
DROP removes the entire table structure and data, requiring recreation to use again

What does @EnableJpaRepositories do in Spring Boot?

@EnableJpaRepositories enables JPA repositories in Spring Boot applications. It scans for interfaces extending Repository and creates implementation beans. Though typically not needed with Spring Boot’s auto-configuration, it’s useful for custom configurations.

Write a query to find students whose names start with the letter ‘A’.

SELECT * FROM students WHERE name LIKE 'A%';
```"SELECT * FROM students WHERE name LIKE 'A%';

Tools & DevOps

Have you worked with any profilers?

Yes, I’ve worked with Java profilers like JProfiler and VisualVM to identify memory leaks and performance bottlenecks. They help pinpoint CPU-intensive methods and analyze heap usage patterns.

Is a profiler a tool or a code snippet?

A profiler is a tool, not code. It’s specialized software that attaches to or instruments your application to collect performance metrics, with minimal configuration needed in your codebase.

Have you used any performance/load testing tools like JMeter?

used JMeter for load testing REST APIs and web applications. It helps simulate heavy user loads and identify throughput limitations. I’ve created test plans with different user scenarios and analyzed response times under various loads.

What happens in Jenkins when image creation is triggered?

When triggered, Jenkins executes the pipeline stages: checkout code, run tests, build the application, create Docker image using Dockerfile, tag it (often with build number), push to registry, and potentially deploy to target environment.

How do you check logs in UAT/Release environment using tools like Dynatrace?

In UAT/Release environments, I access Dynatrace to view application logs through its dashboard. You can filter by service, time period, and severity. It provides transaction tracing to follow requests across microservices and analyze performance metrics alongside logs.”

Spring Boot / Microservices

How does a Spring Boot application start?

“Spring Boot applications start through a specific sequence:

The main() method calls SpringApplication.run(), passing the application class
Spring detects @SpringBootApplication, which combines @Configuration, @ComponentScan, and @EnableAutoConfiguration
The embedded server (Tomcat, Jetty, etc.) initializes
Spring creates the application context
Auto-configuration runs, configuring beans based on classpath and properties
Component scanning finds and registers @Component, @Service, etc.
Bean dependencies are injected
ApplicationRunner and CommandLineRunner beans execute
The application is ready to handle requests

This bootstrapping process happens without XML configuration, following Spring Boot’s ‘convention over configuration’ principle.”

What annotations are used in the Spring Boot main class?

“The main class in Spring Boot primarily uses @SpringBootApplication, which is a composite annotation that combines:

@Configuration: Marks the class as a bean definition source
@EnableAutoConfiguration: Enables Spring Boot’s auto-configuration mechanism
@ComponentScan: Scans for components in the application package

Developers occasionally add other annotations like @EnableJpaRepositories, @EntityScan, @EnableAsync, or @EnableScheduling when specific functionality needs to be explicitly enabled, though Spring Boot often auto-configures these based on dependencies.”

Have you used GraphQL or Spring Security?

“GraphQL: Yes, I’ve implemented it in Spring applications using the spring-graphql library. I’ve defined schemas with types, queries and mutations, then built resolvers to handle data fetching. GraphQL has been valuable for frontend teams who need flexible data fetching without multiple REST endpoints.

Spring Security: I’ve used it extensively for authentication and authorization. I’ve configured security contexts, implemented form and JWT authentication, set up method-level security with @PreAuthorize, and integrated with OAuth2 providers. I typically extend WebSecurityConfigurerAdapter (pre-Spring 5.7) or use SecurityFilterChain beans to customize security rules based on application requirements.”

Have you implemented JWT or OAuth2?

“Yes, I’ve implemented both:

JWT: I’ve built token-based authentication systems using JWTs with Spring Security. This involved creating a filter to validate tokens, configuring secret keys for signing, handling token generation during login, and setting claims for user details and permissions. I’ve also implemented token refresh mechanisms and expiration handling.

OAuth2: I’ve configured Spring applications as OAuth2 clients to authenticate against providers like Google and GitHub. I’ve also implemented OAuth2 resource servers that validate tokens and authorize based on scopes. The implementation involved configuring security filters, token validators, and integrating with Spring’s authentication managers to protect endpoints based on roles derived from token claims.”