A Servlet (short for "Serverlet") is a Java-based program that extends the capabilities of a web server to handle dynamic content and interact with clients (typically web browsers) using the HTTP protocol. Servlets are a key component of Java Enterprise Edition (Java EE) and are commonly used for building web applications in Java.

36 Advanced Java Interview Questions and Answers (2026)

Q: Explain encapsulation in Java.

Encapsulation: Bundling data (fields) and methods that operate on the data into a single unit (class). Access to the data is restricted through public methods. public class Person { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } }

Q: Explain inheritance in Java.

Inheritance: Mechanism where one class (subclass) inherits fields and methods from another class (superclass), promoting code reuse. public class Animal { public void eat() { System.out.println("This animal eats food."); } } public class Dog extends Animal { public void bark() { System.out.println("The dog barks."); } }

Q: Explain polymorphism in Java.

Polymorphism: Ability of a single interface to represent different underlying forms (method overriding and method overloading). Animal myDog = new Dog(); myDog.eat(); // Calls Dog's implementation if overridden, otherwise Animal's.

Q: Explain abstraction in Java.

Abstraction: Hiding the complex implementation details and showing only the essential features of the object. abstract class Shape { abstract void draw(); } public class Circle extends Shape { void draw() { System.out.println("Drawing a circle."); } }

Blog / 36 Advanced Java Interview Questions and Answers (2026)

$138,886

What's that number you're asking?

That's the average salary earned by Java developers according to recent studies.

Not bad, not bad at all.

With salaries like that and Java being the 7th most popular programming language in existence...

It's never been a better time to upgrade your Java skills.

Q1.

Explain encapsulation in Java.

Mid

Encapsulation: Bundling data (fields) and methods that operate on the data into a single unit (class). Access to the data is restricted through public methods.

java

public class Person {
    private String name;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

Q2.

Explain inheritance in Java.

Mid

Inheritance: Mechanism where one class (subclass) inherits fields and methods from another class (superclass), promoting code reuse.

java

public class Animal {
    public void eat() {
        System.out.println("This animal eats food.");
    }
}
 
public class Dog extends Animal {
    public void bark() {
        System.out.println("The dog barks.");
    }
}

Q3.

Explain polymorphism in Java.

Mid

Polymorphism: Ability of a single interface to represent different underlying forms (method overriding and method overloading).

java

Animal myDog = new Dog();
myDog.eat(); // Calls Dog's implementation if overridden, otherwise Animal's.

Preparing for a tech interview?👉Top questions

Q4.

Explain abstraction in Java.

Mid

Abstraction: Hiding the complex implementation details and showing only the essential features of the object.

java

abstract class Shape {
    abstract void draw();
}
 
public class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle.");
    }
}

Q5.

What is the 'IS-A' relationship in Java OOP?

Mid

The 'IS-A' relationship in Java OOP represents inheritance, where a subclass inherits from a superclass. It indicates that an object of the subclass can be treated as an object of the superclass.
Example:
java
class Animal { } // Superclass class Dog extends Animal { } // Dog IS-A Animal
- In this example, Dog inherits from Animal, establishing an 'IS-A' relationship.

Don't let one question ruin your next technical interview...

JavaScript•90

Python•97

OOP•41

Q6.

What is the difference between aggregation and composition?

Mid

Aggregation and composition are both types of associations in object-oriented design that describe relationships between objects.

Aggregation is a weak association where one object (the whole) contains or uses another object (the part), but the part can exist independently of the whole. For example, a university aggregates departments, but if the university closes, the departments might still exist elsewhere.
Composition is a strong association where the part's lifecycle is managed by the whole. The part cannot exist without the whole, and if the whole is destroyed, so is the part. For example, a house composes rooms; if the house is demolished, the rooms cease to exist.

Difference: In aggregation, the part can exist independently of the whole, whereas in composition, the part cannot exist independently and is tightly bound to the whole's lifecycle.

Q7.

What is method overriding?

Mid

Method overriding in Java allows a subclass provides a specific implementation of a method that is already defined in its superclass.
Enables runtime polymorphism and allows a subclass to provide a specific behavior.

java

public class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}
public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

Q8.

What is method overloading?

Mid

Multiple methods with the same name but different parameters (different type, number, or both) within the same class. Provides flexibility and readability.

java

public class MathUtil {
    public int add(int a, int b) {
        return a + b;
    }
 
    public double add(double a, double b) {
        return a + b;
    }
}

Q9.

Can a static method be overloaded in Java?

Mid

Yes, a static method can be overloaded in Java. Overloading means having multiple methods with the same name but different parameters within the same class.

java

public class Example {
    public static void print() {
        System.out.println("No parameters");
    }
 
    public static void print(String message) {
        System.out.println("Message: " + message);
    }
}

Q10.

Explain the concept of constructor overloading.

Mid

Constructor overloading in Java is the practice of defining multiple constructors within a class, each with different parameter lists. This allows objects to be instantiated in different ways.
java
public class Person { private String name; private int age; // Constructor with no parameters public Person() { this.name = "Unknown"; this.age = 0; } // Constructor with one parameter public Person(String name) { this.name = name; this.age = 0; } // Constructor with two parameters public Person(String name, int age) { this.name = name; this.age = age; } }

Q11.

What is runtime polymorphism?

Mid

Runtime polymorphism in Java is the ability of a method to do different things based on the object it is acting upon, determined at runtime.
It is achieved through method overriding, where a subclass provides a specific implementation of a method already defined in its superclass.

java

class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}
 
class Dog extends Animal {
    void sound() {
        System.out.println("Bark");
    }
} 
 
public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.sound(); // Outputs "Bark"
    }
}

Q12.

What is covariant return type?

Mid

A covariant return type is a feature in object-oriented programming languages like Java that allows an overriding method in a subclass to return a type that is a subclass of the return type declared in the overridden method of the superclass. This means the subclass method can provide a more specific return type, enhancing type safety and flexibility.
Example:
java
class Animal { Animal create() { return new Animal(); } } class Dog extends Animal { @Override Dog create() { return new Dog(); } }

Q13.

Explain the concept of Java Generics.

Mid

Java Generics allow you to write code that works with different types while maintaining type safety. It helps in writing reusable code by defining classes, interfaces, and methods with type parameters. Generics ensure that the types are known at compile-time, reducing the risk of runtime errors.

java

class Box<T> {
    private T content;
    public void set(T content) { this.content = content; }
    public T get() { return content; }
}
 
// Usage
Box<Integer> integerBox = new Box<>();
integerBox.set(123);  // Works with Integer
// integerBox.set("hello");  // Compile-time error, wrong type

Q14.

What is a Servlet?

Mid

A Servlet (short for "Serverlet") is a Java-based program that extends the capabilities of a web server to handle dynamic content and interact with clients (typically web browsers) using the HTTP protocol.
Servlets are a key component of Java Enterprise Edition (Java EE) and are commonly used for building web applications in Java.

Q15.

What is the life-cycle of a Servlet?

Mid

The life-cycle of a servlet in Java involves three main stages:
- Initialization: The servlet is instantiated and initialized using the init() method.
- Request Handling: The servlet processes client requests using the service() method.
- Termination: The servlet is taken out of service and destroyed using the destroy() method.
Example:
java
public class MyServlet extends HttpServlet { public void init() throws ServletException { // Initialization code } public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // Request handling code } public void destroy() { // Cleanup code } }

Q16.

What is Object Cloning in Java?

Mid

Object cloning in Java creates an exact copy of an object using the clone() method. The object must implement the Cloneable interface to avoid CloneNotSupportedException. Cloning can be:

Shallow Cloning: Copies the object's fields, but not the objects referenced by those fields.
Deep Cloning: Copies the object and all objects referenced by it.
Example:
java
class Person implements Cloneable { String name; int age; public Person(String name, int age) { this.name = name; this.age = age; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } } public class Main { public static void main(String[] args) { try { Person original = new Person("John", 25); Person clone = (Person) original.clone(); System.out.println(original.name); // John System.out.println(clone.name); // John System.out.println(original == clone); // false, different objects } catch (CloneNotSupportedException e) { e.printStackTrace(); } } }

Q17.

Q18.