Polymorphism - Notes by Shariq SP

Understanding Polymorphism in Java

Polymorphism is a fundamental concept in object-oriented programming that allows objects of different classes to be treated as objects of a common superclass. It enables flexibility and extensibility in the code by allowing methods to behave differently based on the object they are called upon.

How Polymorphism Works in Java

In Java, polymorphism is achieved through method overriding and method overloading.

• Method Overriding: Subclasses can provide a specific implementation of a method defined in their superclass. When a method is called on an object of the subclass, the overridden method in the subclass is executed.
• Method Overloading: Multiple methods with the same name but different parameters can be defined within the same class or across different classes. The appropriate method to be executed is determined at compile time based on the method signature.

Types of Polymorphism

There are two main types of polymorphism in Java:

1. Compile-Time Polymorphism: Also known as static polymorphism, it occurs when the method to be invoked is determined at compile time. Method overloading is an example of compile-time polymorphism.
2. Runtime Polymorphism: Also known as dynamic polymorphism, it occurs when the method to be invoked is determined at runtime. Method overriding is an example of runtime polymorphism.

Example of Polymorphism in Java

Consider the following example:

            class Animal {
                void sound() {
                    System.out.println("Animal makes a sound");
                }
            }
        
            class Dog extends Animal {
                void sound() {
                    System.out.println("Dog barks");
                }
            }
        
            class Cat extends Animal {
                void sound() {
                    System.out.println("Cat meows");
                }
            }
        
            public class Main {
                public static void main(String[] args) {
                    Animal dog = new Dog();
                    Animal cat = new Cat();
                    
                    dog.sound(); // Output: Dog barks
                    cat.sound(); // Output: Cat meows
                }
            }
            

In the example above, both Dog and Cat classes override the sound() method defined in the Animal class. When the sound() method is called on objects of type Dog and Cat, the respective overridden methods are executed, demonstrating runtime polymorphism.

Understanding Compile-Time Polymorphism in Java

Compile-time polymorphism, also known as static polymorphism, occurs when the method to be executed is determined at compile time based on the method signature. It is achieved through method overloading, where multiple methods with the same name but different parameters are defined within the same class or across different classes.

How Compile-Time Polymorphism Works

In Java, compile-time polymorphism is achieved through method overloading. When a method is invoked, the compiler determines which method to call based on the number, type, and order of the parameters passed to the method.

Important Points to Remember

• Method overloading enables compile-time polymorphism by allowing multiple methods with the same name but different parameters.
• The compiler determines which overloaded method to call based on the method signature (number and type of parameters).
• Return type alone is not sufficient to differentiate overloaded methods.
• Overloaded methods can have different access modifiers, but they must not differ only by the return type.

Example of Compile-Time Polymorphism in Java

Consider the following example:

            public class Calculator {
                public int add(int a, int b) {
                    return a + b;
                }
        
                public double add(double a, double b) {
                    return a + b;
                }
        
                public int add(int a, int b, int c) {
                    return a + b + c;
                }
            }
        
            public class Main {
                public static void main(String[] args) {
                    Calculator calculator = new Calculator();
                    
                    int sum1 = calculator.add(5, 10); // Invokes the first add method
                    double sum2 = calculator.add(3.5, 2.5); // Invokes the second add method
                    int sum3 = calculator.add(1, 2, 3); // Invokes the third add method
                }
            }
            

In the example above, the Calculator class defines three overloaded add() methods with different parameter lists. The compiler determines which method to call based on the number and types of arguments passed to the method, demonstrating compile-time polymorphism.

Understanding Runtime Polymorphism in Java

Runtime polymorphism, also known as dynamic polymorphism, occurs when the method to be executed is determined at runtime based on the actual object type rather than the reference type. It is achieved through method overriding, where a subclass provides a specific implementation of a method defined in its superclass.

How Runtime Polymorphism Works

In Java, runtime polymorphism is achieved through method overriding. When a method is called on an object of a subclass, the JVM determines which version of the method to execute based on the actual type of the object at runtime.

Important Points to Remember

• Method overriding enables runtime polymorphism by allowing subclasses to provide specific implementations of methods defined in their superclass.
• The version of the method to be executed is determined based on the actual type of the object at runtime, not the reference type.
• Subclasses can override methods inherited from their superclass to provide custom behavior.
• Method overriding requires the method signature (name, parameters, and return type) to be the same in both the superclass and subclass.

Example of Runtime Polymorphism in Java

Consider the following example:

            class Animal {
                void sound() {
                    System.out.println("Animal makes a sound");
                }
            }
        
            class Dog extends Animal {
                void sound() {
                    System.out.println("Dog barks");
                }
            }
        
            class Cat extends Animal {
                void sound() {
                    System.out.println("Cat meows");
                }
            }
        
            public class Main {
                public static void main(String[] args) {
                    Animal dog = new Dog();
                    Animal cat = new Cat();
                    
                    dog.sound(); // Output: Dog barks
                    cat.sound(); // Output: Cat meows
                }
            }
            

In the example above, the Dog and Cat classes override the sound() method defined in the Animal class. When the sound() method is called on objects of type Dog and Cat, the respective overridden methods are executed at runtime, demonstrating runtime polymorphism.

Interview Questions on Polymorphism and its Types in Java

1. What is polymorphism in Java?
2. Explain the types of polymorphism in Java.
3. What is compile-time polymorphism?
4. How is method overloading achieved in Java?
5. What are the rules for method overloading?
6. Explain the concept of method overriding.
7. What is dynamic (runtime) polymorphism?
8. How is method overriding achieved in Java?
9. What are the rules for method overriding?
10. What is the difference between method overloading and method overriding?
11. Can static methods be overridden in Java?
12. Can private methods be overridden in Java?
13. Can constructors be overridden in Java?
14. Explain the concept of covariant return types.
15. What is the significance of @Override annotation in method overriding?
16. What is the difference between method overloading and constructor overloading?
17. How does Java determine which method to call during method overloading?
18. How does Java determine which method to call during method overriding?
19. What is polymorphic method invocation?
20. Explain the concept of abstract classes and polymorphism.
21. How does polymorphism contribute to code reusability and flexibility?
22. What are the benefits of using polymorphism in Java?
23. How do you prevent method overriding in Java?
24. What is the role of interfaces in achieving polymorphism?
25. Can you provide an example of polymorphic behavior in Java?
26. Explain the concept of method hiding in polymorphism.
27. How does polymorphism enhance code maintainability?
28. Can you achieve polymorphism without inheritance in Java?

Multiple Choice Questions on Polymorphism and its Types in Java

1. What is polymorphism?
1. Having multiple constructors in a class.
2. The ability of a method to do different things based on the object it is acting upon.
3. The ability of a class to have multiple methods with the same name.
4. The process of converting one data type to another.
2. Which of the following is an example of compile-time polymorphism?
1. Method overriding
2. Method overloading
3. Dynamic polymorphism
4. Operator overloading
3. What is method overloading?
1. Having multiple methods with the same name but different parameters.
2. Having multiple methods with the same name and same parameters.
3. Having multiple methods with different return types.
4. Having multiple constructors in a class.
4. Which of the following is true about method overriding?
1. It occurs at compile time.
2. It occurs at runtime.
3. It involves creating multiple methods with the same name in a class.
4. It involves creating multiple methods with different names in a class.
5. Can a static method be overridden in Java?
1. Yes
2. No
3. It depends on the visibility of the method.
4. It depends on the return type of the method.
6. What is dynamic polymorphism?
1. Having multiple methods with the same name but different parameters.
2. Having multiple methods with the same name and same parameters.
3. It occurs at compile time.
4. It occurs at runtime.
7. Which keyword is used to indicate that a method is being overridden?
1. override
2. final
3. super
4. @Override
8. What is the role of interfaces in achieving polymorphism?
1. Interfaces cannot be used to achieve polymorphism.
2. Interfaces provide a way to implement dynamic polymorphism.
3. Interfaces provide a way to implement method overloading.
4. Interfaces provide a way to implement compile-time polymorphism.
9. Which of the following statements is true about polymorphism?
1. Polymorphism allows a class to inherit from multiple classes.
2. Polymorphism allows a method to have multiple return types.
3. Polymorphism allows objects of different classes to be treated as objects of the same class hierarchy.
4. Polymorphism allows a class to have multiple constructors.
10. What is the benefit of polymorphism?
1. It reduces memory consumption.
2. It allows for code reuse.
3. It makes the code less readable.
4. It increases runtime errors.
11. Can a constructor be overridden in Java?
1. Yes
2. No
3. It depends on the visibility of the constructor.
4. It depends on the superclass.
12. Which of the following is an example of method hiding?
1. Method overloading
2. Method overriding
3. Static method in a subclass with the same signature as a static method in the superclass
4. Dynamic polymorphism
13. What is the significance of the @Override annotation?
1. It indicates that a method is overloaded.
2. It indicates that a method is overridden.
3. It indicates that a method is abstract.
4. It indicates that a method is static.
14. Can you achieve polymorphism without inheritance in Java?
1. Yes
2. No
3. It depends on the version of Java.
4. It depends on the IDE used.
15. Which keyword is used to indicate that a method is being overloaded?
1. override
2. final
3. super
4. @Override
16. What is the main difference between method overloading and method overriding?
1. Method overloading occurs at compile time, while method overriding occurs at runtime.
2. Method overloading involves creating multiple methods with the same name but different parameters, while method overriding involves creating multiple methods with the same name and parameters.
3. Method overloading allows a subclass to provide a specific implementation of a method defined in a superclass, while method overriding allows a subclass to provide a more specific implementation of a method defined in a superclass.
4. Method overloading allows a method to have multiple return types, while method overriding does not.
17. Which of the following is not a valid access specifier for an overridden method?
1. public
2. protected
3. default
4. private
18. How do you achieve polymorphism in Java?
1. By using inheritance
2. By using interfaces
3. By using method overloading
4. All of the above
19. What is the main purpose of polymorphism?
1. To reduce code complexity
2. To increase code readability
3. To improve code reusability
4. To decrease code size
20. Can constructors be inherited in Java?
1. Yes
2. No
3. It depends on the visibility of the constructor.
4. It depends on the superclass.