Polymorphism, a foundational concept in object-oriented programming (OOP), allows methods or functions to process objects differently based on their data type or class. In Java, polymorphism enables one interface to be used for a general class of actions, allowing a program to behave dynamically depending on the context. This tutorial explains polymorphism, covers its types and benefits, and illustrates its implementation in Java.<\/p>\n\n\n\n
Polymorphism, from Greek words meaning “many forms,” refers to the ability of an object to take on multiple forms. It allows a single function or method to work differently based on the object calling it, which enhances code flexibility and reusability. In Java, polymorphism can be achieved through:<\/p>\n\n\n\n
In function overloading<\/strong>, multiple methods in the same class have the same name but different parameter lists. The compiler determines which method to call based on the method signature. This decision is made during compilation, hence the term “compile-time polymorphism.”<\/p>\n\n\n\n In this example:<\/p>\n\n\n\n In method overriding<\/strong>, a subclass provides a specific implementation of a method that is already defined in its superclass. This type of polymorphism is resolved during runtime. Run-time polymorphism supports the concept of “one interface, many methods” by allowing different subclasses to provide their unique implementations of a superclass method.<\/p>\n\n\n\n In this example:<\/p>\n\n\n\n Java uses upcasting<\/strong> to handle method calls at runtime. When a superclass reference points to a subclass object, it can call overridden methods in the subclass based on the object’s actual type. This process is known as dynamic method dispatch<\/strong> and is a key feature of runtime polymorphism.<\/p>\n\n\n\n Code Reusability<\/strong>: Reusable code is a major advantage of polymorphism. Methods with the same name can work with different types or classes, reducing code redundancy.<\/p>\n\n\n\n Extensibility<\/strong>: New classes and methods can be added with minimal changes to existing code, as polymorphic behavior is inherently adaptable.<\/p>\n\n\n\n Maintainability<\/strong>: A polymorphic approach improves code organization, making the codebase easier to manage and maintain.<\/p>\n\n\n\n Consider a payment system with different payment methods like CreditCard<\/strong> and PayPal<\/strong>. Polymorphism allows creating a general In this system:<\/p>\n\n\n\n Java interfaces support polymorphism by allowing a class to implement multiple interfaces. This approach can lead to flexible and extensible designs.<\/p>\n\n\n\nExample of Method Overloading<\/h4>\n\n\n\n
class Calculator {\n \/\/ Method to add two integers\n int add(int a, int b) {\n return a + b;\n }\n\n \/\/ Method to add three integers\n int add(int a, int b, int c) {\n return a + b + c;\n }\n\n \/\/ Method to add two double values\n double add(double a, double b) {\n return a + b;\n }\n}\n\npublic class TestCalculator {\n public static void main(String[] args) {\n Calculator calculator = new Calculator();\n\n System.out.println(\"Add two integers: \" + calculator.add(5, 10));\n System.out.println(\"Add three integers: \" + calculator.add(5, 10, 15));\n System.out.println(\"Add two doubles: \" + calculator.add(5.5, 10.5));\n }\n}<\/code><\/pre>\n\n\n\n\n
Calculator<\/code> class defines three add<\/code> methods with different parameters.<\/li>\n\n\n\n2. Run-time polymorphism (Method Overriding)<\/h3>\n\n\n\n
Example of Method Overriding<\/h4>\n\n\n\n
class Car {\n void drive() {\n System.out.println(\"The car is driving.\");\n }\n}\n\nclass Sedan extends Car {\n @Override\n void drive() {\n System.out.println(\"The Sedan run smoothly on the highway.\");\n }\n}\n\nclass SUV extends Car {\n @Override\n void drive() {\n System.out.println(\"The SUV run smoothly on the highway.\");\n }\n}\n\nclass SportsCar extends Car {\n @Override\n void drive() {\n System.out.println(\"The SportsCar zooms at high speed on the track.\");\n }\n}\n\npublic class CarTest {\n public static void main(String[] args) {\n Car mySedan = new Sedan();\n Car mySUV = new SUV();\n Car mySportsCar = new SportsCar();\n \n mySedan.drive(); \n mySUV.drive(); \n mySportsCar.drive(); \n }\n}\n<\/code><\/pre>\n\n\n\n\n
Car<\/code> superclass provides a generic drive<\/code> method. Each subclass (Sedan, SUV, and SportsCar) overrides drive with its unique behaviour. Using a Car reference for different car types enables polymorphic behaviour at runtime through dynamic method dispatch<\/strong>.<\/li>\n<\/ul>\n\n\n\nUpcasting and Dynamic Method Dispatch<\/h3>\n\n\n\n
Car Suv = new Car(); \/\/ Upcasting\nSuv.drive(); \/\/ Calls drive method due to dynamic method dispatch<\/code><\/pre>\n\n\n\nBenefits of Polymorphism<\/h3>\n\n\n\n
\n
Real-World Example: A Payment System<\/h3>\n\n\n\n
Payment<\/code> interface that can handle different payment methods dynamically.<\/p>\n\n\n\ninterface Payment {\n void makePayment(double amount);\n}\n\nclass CreditCard implements Payment {\n @Override\n public void makePayment(double amount) {\n System.out.println(\"Paid \" + amount + \" with Credit Card.\");\n }\n}\n\nclass PayPal implements Payment {\n @Override\n public void makePayment(double amount) {\n System.out.println(\"Paid \" + amount + \" via PayPal.\");\n }\n}\n\npublic class PaymentSystem {\n public static void main(String[] args) {\n Payment payment1 = new CreditCard();\n Payment payment2 = new PayPal();\n\n payment1.makePayment(100.00);\n payment2.makePayment(250.00);\n }\n}<\/code><\/pre>\n\n\n\n\n
CreditCard<\/code> and PayPal<\/code> classes implement the Payment<\/code> interface.<\/li>\n\n\n\nPayment<\/code> reference, the program dynamically decides the payment method, showcasing polymorphism in action.<\/li>\n<\/ul>\n\n\n\nDifferences Between Method Overloading and Method Overriding<\/h3>\n\n\n\n
Aspect<\/th> Method Overloading<\/th> Method Overriding<\/th><\/tr><\/thead> Purpose<\/td> To define multiple methods with the same name but different parameters.<\/td> To provide a specific implementation in a subclass for a superclass method.<\/td><\/tr> Binding<\/td> Compile-time<\/td> Run-time<\/td><\/tr> Scope<\/td> Within the same class<\/td> Across a superclass-subclass hierarchy<\/td><\/tr> Return Type<\/td> Can differ<\/td> Must be the same or covariant<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Polymorphism in Interfaces<\/h3>\n\n\n\n
interface Drawable {\n void draw();\n}\n\nclass Circle implements Drawable {\n public void draw() {\n System.out.println(\"Drawing a Circle\");\n }\n}\n\nclass Square implements Drawable {\n public void draw() {\n System.out.println(\"Drawing a Square\");\n }\n}\n\npublic class ShapeTest {\n public static void main(String[] args) {\n Drawable shape1 = new Circle();\n Drawable shape2 = new Square();\n\n shape1.draw(); \/\/ Outputs \"Drawing a Circle\"\n shape2.draw(); \/\/ Outputs \"Drawing a Square\"\n }\n}<\/code><\/pre>\n\n\n\nBest Practices for Using Polymorphism in Java<\/h3>\n\n\n\n
\n
@Override<\/code> Annotation<\/strong>: This helps ensure methods are correctly overridden and improves code readability.<\/li>\n\n\n\n