Define polymorphism in Object-Oriented Programming using examples.
Resources & Suggestions
Mains Answer Writing Latest Articles
On: February 22, 2025
Comments:
0
Indo-US Relation: Areas of Cooperation & Conflicts
Key Areas: Defense, technology, trade, energy, and regional cooperation. Key Areas of Cooperation 1. Defense and Security Transition from buyer-seller to co-production and technology sharing. India as a Major Defense Partner (MDP) and inclusion in STA-1. Access to advanced technologies, ...
On: February 22, 2025
Comments:
0
भारत-अमेरिका संबंध: सहयोग और संघर्ष के क्षेत्र
मुख्य विषय: भारत-अमेरिका संबंधों की मजबूती, विशेषकर रक्षा, प्रौद्योगिकी और क्षेत्रीय सहयोग में प्रगति। सहयोग के प्रमुख क्षेत्र 1. रक्षा एवं सुरक्षा सहयोग भारत और अमेरिका के बीच रक्षा संबंधों का विस्तार। प्रमुख रक्षा साझेदार (MDP) का दर्जा और STA-1 ...
On: February 22, 2025
Comments:
0
India’s Disaster Management
The article discusses the growing tensions between the Centre and states regarding disaster relief funding in India. It emphasizes the need for a transparent and equitable disaster management framework. Key Disaster Threats India Faces Increasing Frequency of Extreme Weather Events ...
Polymorphism is a fundamental concept in Object-Oriented Programming (OOP) that allows objects to be treated as instances of their parent class rather than their actual class. This enables a single function or method to operate on objects of different classes, which can result in more flexible and maintainable code. There are two main types of polymorphism in OOP: compile-time (or static) polymorphism and runtime (or dynamic) polymorphism.
Compile-time Polymorphism (Method Overloading)
Compile-time polymorphism is achieved through method overloading, where multiple methods have the same name but differ in the type or number of their parameters. The correct method to call is determined at compile time.
Example in Java:
class Calculator {// Method to add two integers
public int add(int a, int b) {
return a + b;
}
// Method to add three integers
public int add(int a, int b, int c) {
return a + b + c;
}
// Method to add two double values
public 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(2, 3)); // Output: 5
System.out.println(calc.add(2, 3, 4)); // Output: 9
System.out.println(calc.add(2.5, 3.5)); // Output: 6.0
}
}
Runtime Polymorphism (Method Overriding)
Runtime polymorphism is achieved through method overriding, where a subclass provides a specific implementation of a method that is already defined in its superclass. The method to be called is determined at runtime.
Example in Java:
class Animal {void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("Dog barks");
}
}
class Cat extends Animal {
@Override
void sound() {
System.out.println("Cat meows");
}
}
public class Main {
public static void main(String[] args) {
Animal myAnimal = new Animal(); // Animal reference and object
Animal myDog = new Dog(); // Animal reference but Dog object
Animal myCat = new Cat(); // Animal reference but Cat object
myAnimal.sound(); // Output: Animal makes a sound
myDog.sound(); // Output: Dog barks
myCat.sound(); // Output: Cat meows
}
}
Polymorphism is a fundamental concept in Object-Oriented Programming (OOP) that allows objects to be treated as instances of their parent class rather than their actual class. This enables a single function or method to operate on objects of different classes, which can result in more flexible and maintainable code. There are two main types of polymorphism in OOP: compile-time (or static) polymorphism and runtime (or dynamic) polymorphism.
Compile-time Polymorphism (Method Overloading)
Compile-time polymorphism is achieved through method overloading, where multiple methods have the same name but differ in the type or number of their parameters. The correct method to call is determined at compile time.
Example in Java:
class Calculator {// Method to add two integers
public int add(int a, int b) {
return a + b;
}
// Method to add three integers
public int add(int a, int b, int c) {
return a + b + c;
}
// Method to add two double values
public 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(2, 3)); // Output: 5
System.out.println(calc.add(2, 3, 4)); // Output: 9
System.out.println(calc.add(2.5, 3.5)); // Output: 6.0
}
}
Runtime Polymorphism (Method Overriding)
Runtime polymorphism is achieved through method overriding, where a subclass provides a specific implementation of a method that is already defined in its superclass. The method to be called is determined at runtime.
Example in Java:
class Animal {void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("Dog barks");
}
}
class Cat extends Animal {
@Override
void sound() {
System.out.println("Cat meows");
}
}
public class Main {
public static void main(String[] args) {
Animal myAnimal = new Animal(); // Animal reference and object
Animal myDog = new Dog(); // Animal reference but Dog object
Animal myCat = new Cat(); // Animal reference but Cat object
myAnimal.sound(); // Output: Animal makes a sound
myDog.sound(); // Output: Dog barks
myCat.sound(); // Output: Cat meows
}
}
Polymorphism in Object-Oriented Programming (OOP) is the ability of objects to respond differently to the same message. Imagine having a “makeSound” function for various animal classes (Dog, Cat). Each class would define its own way to make a sound (“woof” for Dog, “meow” for Cat).
Here’s the benefit: you can write code that calls “makeSound” on any animal object, without knowing the exact type. The correct implementation will be invoked based on the actual object. This makes code flexible and reusable.
This is achieved through inheritance (subclasses inheriting the function) and method overriding (subclasses providing their specific implementation).
Polymorphism in Object-Oriented Programming allows methods to do different things based on the object it is acting upon, even if they share the same name. It lets one interface be used for a general class of actions, making code more flexible and reusable.
Imagine you have a book class with a method called “summary()”. If you create two types of books, “novel” and “biography”, each type can have its own version of “summary()”. When you use the “summary()” method on a book, it will show the right summary based on whether the book is a “novel” or a “biography”. Even though you use the same method name, it does different things depending on the type of book.
In this simpler code, the “summar()” method in the “book” class provides a general description, while the “novel” and “biography” classes override it with their specific summaries.