What is the difference between an abstract method and a virtual method?

 

Abstract methods and virtual methods are both concepts in object-oriented programming, but they serve different purposes and have distinct characteristics. Let's explore the differences between them, and I'll provide an example in Python.

1. Abstract Method:

   • An abstract method is a method declared in an abstract class but does not have an implementation in the abstract class itself.
   • Abstract methods are meant to be overridden (implemented) by subclasses that inherit from the abstract class.
   • Abstract classes are often used to define a common interface or contract that derived classes must adhere to, ensuring that certain methods are implemented in each subclass.
   • Abstract methods are declared using the @abstractmethod decorator in Python.

2. Virtual Method:

   • A virtual method is a method declared in a base class that can be overridden in derived classes.
   • Virtual methods have a default implementation in the base class, but this implementation can be replaced or extended in derived classes.
   • Virtual methods allow for polymorphism, where objects of derived classes can be treated as objects of the base class.
   • In Python, all methods are effectively virtual by default, meaning they can be overridden in derived classes. The @abstractmethod decorator is not required for this behavior.

Here's an example in Python that illustrates abstract methods and virtual methods:

python

from abc import ABC, abstractmethod

# Abstract class with an abstract method
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# Concrete class Circle that inherits from Shape
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    # Implementing the abstract method area for Circle
    def area(self):
        return 3.14159 * self.radius ** 2

# Concrete class Rectangle that inherits from Shape
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    # Implementing the abstract method area for Rectangle
    def area(self):
        return self.width * self.height

# Create instances of Circle and Rectangle
circle = Circle(5)
rectangle = Rectangle(4, 6)

# Calling the area method on both objects
print("Circle Area:", circle.area())       # Calls Circle's area method
print("Rectangle Area:", rectangle.area()) # Calls Rectangle's area method

In this example:

• Shape is an abstract class that defines an abstract method area. This method must be overridden in concrete subclasses of Shape.

• Circle and Rectangle are concrete subclasses of Shape. They both override the area method to provide their own implementations.

• When we create instances of Circle and Rectangle, we can call the area method on these objects. The correct implementation of the area method is called based on the object's actual class.

In summary, abstract methods define a contract that derived classes must adhere to, while virtual methods provide a default implementation that can be overridden in derived classes. In Python, all methods are effectively virtual, but you can use the @abstractmethod decorator to explicitly declare abstract methods and enforce their implementation in derived classes.