Top Polymorphism Interview Questions for Java Developers

Polymorphism is one of the key concepts in object-oriented programming languages like Java It refers to the ability of objects belonging to different data types to respond to the same method call. During Java interviews, candidates are often asked various questions on polymorphism to test their understanding of this important concept

In this article we will look at some of the most frequently asked polymorphism interview questions for Java developers along with sample answers.

What is Polymorphism?

Polymorphism means “many forms”. It describes the ability of objects from different classes to respond to the same method call. So a polymorphic method call results in different functionalities depending on the object it is called on.

For example think of the method call animal.makeSound(). If animal is an object of the Cat class, it will meow. If animal is an object of the Dog class it will bark. So the makeSound() method exhibits polymorphic behavior.

The two main types of polymorphism in Java are:

• Compile-time polymorphism achieved through method overloading
• Runtime polymorphism achieved through method overriding

What is Polymorphism in Java?

In Java, polymorphism manifests in two forms:

1. Overloading – When there are multiple methods with the same name but different parameters, it is known as overloading. Overloading is a form of compile-time polymorphism.

2. Overriding – When a subclass provides a specific implementation of a method already defined in its parent class, it is known as overriding. Overriding is a form of runtime polymorphism.

Through method overloading and overriding, we can invoke methods differently based on the runtime object type. This polymorphic behavior allows us to easily extend code without modifying existing code.

What is Function Overloading?

Function overloading refers to defining two or more functions with the same name but different parameters. The compiler determines which function to call based on the number and type of arguments passed.

For example:

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

Here, we have overloaded the add() method. The compiler will choose the appropriate version based on whether we pass int or double arguments.

Overloading provides polymorphic behavior at compile time and does not require inheritance.

What is the Difference Between ‘Overloading’ and ‘Overriding’?

What is Function Overriding and Overloading in Java?

Function Overloading means defining two or more functions with the same name but different parameters. It allows us to perform different tasks with the same method name. It is a form of compile-time polymorphism.

Function Overriding means providing a specific implementation of a method that is already defined in its parent class. It allows a subclass to change the implementation of a method inherited from its parent class. It is a form of run-time polymorphism.

For example:

class Animal {  public void makeSound(){    System.out.println("Some generic sound");   }}class Dog extends Animal {  //This overrides the makeSound() method of the parent Animal class  public void makeSound(){    System.out.println("Bark bark");  } }

Here, Dog is overriding the makeSound() method to provide custom implementation while inheriting other features from the Animal parent class.

What is a Static Member Class?

A static member class (sometimes called a nested static class) is a static class defined at the member level inside another class or interface. It can be accessed without requiring an object of the enclosing class.

For example:

class OuterClass {    static class NestedStaticClass {    ...  }}//Accessing nested static classOuterClass.NestedStaticClass nestedObject = new OuterClass.NestedStaticClass(); 

Static nested classes cannot access non-static members of the outer class. They do not have polymorphic relation with outer classes.

What are Non-static Inner Classes?

A non-static inner class (or nested inner class) is a class defined at the member level inside another class just like the static nested class. However, it cannot be declared as static.

The key difference is that an inner class object maintains an implicit reference to the object of the enclosing class. So it can freely access the members of the outer class including private members.

For example:

class OuterClass {  private int x = 10;     class InnerClass {    public int getX() {      return x; //can access private member    }  }}  

Here, InnerClass can access the private variable x of OuterClass. An inner class exhibits polymorphic behavior with respect to its outer class.

• Non-static inner classes can access members of the enclosing class whereas static nested classes cannot.
• Objects of an inner class are associated with an instance of enclosing class whereas static class objects are not.
• There is an IS-A relationship between inner classes and enclosing classes, whereas there is no such relationship between static nested classes and enclosing classes.

These are some of the commonly asked interview questions on polymorphism in Java. Having a good understanding of overloading, overriding, inheritance, and nested classes is essential to tackle these questions confidently.