Polymorphism is a fundamental concept in object-oriented programming that allows objects of different classes to be treated as objects of a common superclass.
Method overriding occurs when a subclass defines a method with the same name as a method in its superclass.
The method in the subclass overrides the implementation of the method in the superclass.
This allows for different implementations of the same method across different classes.
Here's an example of method overriding in Python:
class Animal: def sound(self): print("Animal makes a sound") class Dog(Animal): def sound(self): print("Dog barks") # Creating instances of different classes animal = Animal() dog = Dog() # Calling the overridden method animal.sound() # Output: Animal makes a sound dog.sound() # Output: Dog barks
In the example above, the
Animal class has a method
Dog class inherit from the
Animal class and override the
make_sound() method with their specific implementations. When
make_sound() is called on an instance of each class, the overridden method in the respective subclass is invoked.
Method overloading refers to defining multiple methods with the same name but different parameters within a class.
Python doesn't support method overloading in the same way as some other languages (e.g., Java), where methods can have different signatures.
However, you can achieve a form of method overloading using default argument values or variable-length arguments.
Here's an example demonstrating method overloading using default argument values:
class Calculator: def add(self, a, b): return a + b def add(self, a, b, c): return a + b + c # Creating an instance of the Calculator class calculator = Calculator() # Calling the overloaded methods result1 = calculator.add(2, 3) result2 = calculator.add(2, 3, 4) print(result1) # Output: 5 print(result2) # Output: 9
In this example, the
Calculator class has two
add() methods with different parameter counts. By providing different parameter lists, we can achieve a form of method overloading.