Polymorphism : MCQs & PYQs with Explanation

Option C

In Java, a method is a block of code that performs a specific task. One of the core features of Java is Polymorphism, which allows objects or methods to take multiple forms.
Method overloading is a type of compile-time polymorphism where a class has two or more methods with the same name but different parameter lists.

• The method name remains the same.
• The parameters must differ in type, number, or sequence (order).
• The return type of method does not play any role in method overloading.

It allows programmers to use the same method name for related actions, improving readability and organization.

class Calculator {
    int add(int a, int b) {
        return a + b;
    }
    int add(int a, int b, int c) {
        return a + b + c;
    }
    double add(double a, double b) {
        return a + b;
    }
}
public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(15, 25));     
        System.out.println(calc.add(15, 12, 30));  
        System.out.println(calc.add(2.5, 7.5));
    }
}

Option A

The word Polymorphism means Many Forms. It allows objects or methods to take multiple forms, enabling flexibility and reusability in code. Polymorphism improves code flexibility, readability, and maintainability. There are two main types of polymorphism in Java:
Compile-Time Polymorphism (Method Overloading):

• A single method name can perform different tasks depending on the number or type of parameters.

Runtime Polymorphism (Method Overriding):

• A subclass can provide a specific implementation of a method already defined in its superclass. At runtime, the actual method that gets called depends on the object type.

Option B

In Java, Method Hiding occurs when a subclass defines a static method with the same signature as a static method in its superclass. Since static methods belong to the class rather than to individual objects, they are hidden, not overridden.
E.g.:
class A 
{
    static void show()
    {
        System.out.println("A show()");
    }
}
class B extends A 
{
    static void show()
    {
        System.out.println("B show()");
    }
}
class TestExample 
{
    public static void main(String args[])
    {
        A obj1 = new B();
        B obj2 = new B();
        obj1.show();
        obj2.show();
    }
}
OUTPUT
A show()
B show()

Here, both A and B have a static method named show(). The method in B hides the method in A.
Notice an important difference from method overriding. With an overridden instance method, Java uses the actual object type at runtime. However, with static methods, the method that is called is determined by the reference or class type.

Method Overloading:
class MyCalculator 
{
    void add(int a, int b)
    {
        System.out.println(a + b);
    }
    void add(int a, int b, int c)
    {
        System.out.println(a + b + c);
    }
}
Method Overriding:
class A 
{
    void show()
    {
        System.out.println("A");
    }
}
class B extends A 
{
    void show()
    {
        System.out.println("B");
    }
}
Method Hiding:
class A 
{
    static void show()
    {
        System.out.println("A");
    }
}
class B extends A 
{
    static void show()
    {
        System.out.println("B");
    }
}

Option B

In Java, Polymorphism means that the same method name can represent different behavior depending on the situation. Polymorphism is commonly divided into Compile-Time Polymorphism and Runtime Polymorphism.
Method Overloading is an example of Compile-Time Polymorphism. In method overloading, multiple methods have the same name but different parameter lists. The compiler determines which method should be called by examining the number, type, or order of arguments during compilation.
E.g.:
class MyCalculator 
{
    int add(int a,int b)
    {
        return a+b;
    }
    int add(int a,int b,int c)
    {
        return a+b+c;
    }
    double add(double a,double b)
    {
        return a+b;
    }
    public static void main(String args[])
    {
        MyCalculator calc = new MyCalculator();
        System.out.println(calc.add(11,22));
        System.out.println(calc.add(11,22,33));
        System.out.println(calc.add(11.5,22.5));
    }
}
OUTPUT
33
66
34.0
The Method Overriding and Dynamic Method Dispatch are associated with Runtime Polymorphism, because the overridden method is selected according to the actual object during execution.

Option B

In Java, Method Overriding occurs when a subclass provides its own implementation of an inherited method with the same method signature. 
The final keyword can be used to prevent a method from being overridden by a subclass. When a method is declared with the final modifier, its implementation cannot be replaced in a subclass.
E.g.:
class Parent
{
    final void display()
    {
        System.out.println("Parent Class Method");
    }
}
class Child extends Parent
{
    void display() // Compilation Error
    {
         System.out.println("Child Class Method");
    }
}