When I appeared for an interview at IBM as an experienced Java developer back in March 2024, I faced some challenging Java developer interview questions. IBM is known for its rigorous interview process, especially for roles involving Java. To succeed, you need a solid grasp of Java fundamentals, design patterns, microservices, Git, Kafka, and ZooKeeper. Imagine stepping into the interview room armed with knowledge, ready to impress the panel. It’s like being a superhero, but instead of fighting crime, you’re tackling code! Let me share the key topics and questions I encountered.
In an interview, the first question they will ask is to introduce yourself, so you need to prepare for this.
Java and Java 8 interview questions
Difference Between Abstraction and Interface
Abstraction: Abstraction is the process of hiding implementation details and showing only essential features of the object. You can achieve this in Java using abstract classes and interfaces.
Interface: An interface in Java is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. It cannot contain instance fields.
What are the default methods and why do we need them?
Default methods were introduced in Java 8 to allow interfaces to have methods with implementation without affecting the classes that implement the interface. These methods are marked with the default keyword and provide default behavior that can be overridden by implementing classes.
Default methods in interfaces allow backward compatibility by providing new methods without breaking existing code. They enable interfaces to evolve over time by adding new methods without requiring all implementing classes to provide an implementation.
Checked and Unchecked Exceptions with Examples
Checked Exception: Checked exceptions are checked at compile-time. Examples include IOException, SQLException. They must be handled using try-catch or declared using throws.
Unchecked Exception: Unchecked exceptions are not checked at compile-time. Examples include NullPointerException, ArrayIndexOutOfBoundsException. They are subclasses of RuntimeException and its subclasses.
Difference Between Exception and RuntimeException
Exception: Exception is a superclass of all checked exceptions. It must be handled using try-catch or declared using throws.
RuntimeException: RuntimeException, a subclass of Exception, represents exceptions that can be avoided with proper coding and do not require explicit handling.
What is a design pattern, and explain the singleton design pattern with an example?
Design patterns are reusable solutions to common problems in software design. They offer templates for solving specific design problems and categorize them into three types: creational, structural, and behavioral patterns. Examples include Singleton, Factory, Adapter, Observer, etc.
Singleton is a creational design pattern that ensures a class has only one instance as per JVM. Implement this by making the constructor private, providing a static method that returns the instance, and using lazy initialization or eager initialization based on requirements.
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
What are the SOLID principles?
SOLID is an acronym for five principles of object-oriented design:
- Single Responsibility Principle (SRP): A class should have only one reason to change.
- Open/Closed Principle (OCP): Software entities should be open for extension but closed for modification.
- Liskov Substitution Principle (LSP): Objects of a superclass should be replaceable with objects of its subclasses without affecting the correctness of the program.
- Interface Segregation Principle (ISP): Clients should not be forced to depend on interfaces they do not use.
- Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules; both should depend on abstractions.
How to Refer Functional Interface in 3 Different Ways?
Lambda expressions are great for short and simple implementations where the logic is straightforward and fits within a single expression. Method references are useful when you have an existing method that matches the functional interface’s signature and want to delegate to it. Anonymous inner classes are handy for one-off implementations or when the implementation logic is more complex and deserves its own block of code.
// Functional interface definition
interface MyFunctionalInterface {
void myMethod();
}
// Class with a method that matches the functional interface
class MyClass {
static void myStaticMethod() {
System.out.println("Inside static method");
}
void myInstanceMethod() {
System.out.println("Inside instance method");
}
}
public class Main {
public static void main(String[] args) {
// Lambda expression
MyFunctionalInterface lambdaFunc = () -> System.out.println("Lambda expression");
lambdaFunc.myMethod();
// Method reference to a static method
MyFunctionalInterface staticMethodRef = MyClass::myStaticMethod;
staticMethodRef.myMethod();
// Method reference to an instance method
MyClass obj = new MyClass();
MyFunctionalInterface instanceMethodRef = obj::myInstanceMethod;
instanceMethodRef.myMethod();
// Anonymous inner class
MyFunctionalInterface anonymousInnerClass = new MyFunctionalInterface() {
@Override
public void myMethod() {
System.out.println("Anonymous inner class");
}
};
anonymousInnerClass.myMethod();
}
}
What is the diamond problem and how do you solve it?
The diamond problem occurs in multiple inheritance when a subclass inherits from two superclasses that have a common ancestor class. It creates ambiguity as to which superclass method should be inherited by the subclass.
Traditional Way: Multiple inheritance is not directly supported in Java to avoid the diamond problem.
Java 8 Approach: Java 8 supports default methods in interfaces, allowing multiple interface inheritance without ambiguity. Interfaces can provide default implementations, and the class implementing these interfaces must override the conflicting methods explicitly.
Java Developer Interview Questions: Postgresql/SQL
Define joins and its types
Joins in SQL combine rows from two or more tables based on a related column between them. Types of joins include:
- Inner Join: Returns rows when there is a match in both tables.
- Outer Join: Returns all rows from one table and matching rows from the other table.
- Left Join (Left Outer Join): Returns all rows from the left table and matching rows from the right table.
- Right Join (Right Outer Join): Returns all rows from the right table and matching rows from the left table.
- Full Join (Full Outer Join): Returns all rows when there is a match in either table.
What is an aggregate function?
An aggregate function in SQL performs a calculation on a set of values and returns a single value as a result. Examples include SUM(), AVG(), COUNT(), MAX(), MIN().
Can We Use Aggregate Functions with Where Clauses?
Yes, aggregate functions can be used with a WHERE clause in SQL to filter rows before applying the aggregate function.
SELECT SUM(salary) FROM employees WHERE department = 'IT';Microservices and related questions
What are eureka servers and service discovery?
Eureka Server is a service discovery server from Netflix that allows microservices to register themselves and discover other services in a cloud environment. It helps in achieving dynamic scaling, load balancing, and fault tolerance by enabling microservices to locate each other without hardcoding service locations.
Service Discovery is the process of automatically detecting and locating services (microservices) within a network. It allows services to register their location and metadata (such as IP address, port, and health status) so that other services can discover and communicate with them.
Why Do We Need Eureka Service Discovery?
Eureka Service Discovery is crucial for microservices architecture because it provides several benefits:
- Fault Tolerance: Enables automatic detection and recovery from service failures by redirecting traffic to healthy instances.
- Dynamic Scaling: Facilitates the addition and removal of service instances dynamically without disrupting the overall system.
- IP Address Management: Eliminates the need for hardcoding IP addresses in client applications, simplifies configuration, and improves scalability.
What is a circuit breaker?
In microservices architecture, a circuit breaker is a design pattern used to handle faults and failures in distributed systems. It monitors the availability of a remote service and prevents continuous requests if the service is unavailable or experiencing issues. It helps in preventing cascading failures and provides fallback mechanisms to maintain system stability.
What is a retryable annotation?
@Retryable annotation in Spring Framework is used to automatically retry a method when a specified type of exception occurs. It allows developers to configure retry attempts, delay between retries, and conditions for retrying failed operations. It simplifies error handling and improves the reliability of methods that may encounter transient failures.
What is API Gateway Configuration (Zuul, Spring API Gateway)?
API Gateway is a server that acts as an API front-end, routing client requests to appropriate backend services. In Spring Cloud, Zuul and Spring Cloud Gateway are popular API Gateway implementations that provide features like routing, filtering, load balancing, and security.
Conclusion
Mastering these Java Developer Interview Questions is essential for succeeding in an IBM interview. They include Java basics, design patterns, microservices, Git for version control, and distributed systems like Kafka and ZooKeeper. After clearing the technical interview, candidates typically face a managerial round focusing on project alignment with company goals. This phase evaluates both technical proficiency and cultural fit, setting the stage for a successful career in Java development at IBM or similar tech companies.
