Dart - 11 - Polymorphism

Polymorphism in Dart Programming

Polymorphism is a fundamental concept in object-oriented programming (OOP) that enables objects of different classes to be treated as objects of a common superclass. In Dart, a versatile and expressive programming language, polymorphism is a powerful mechanism that enhances code flexibility, reusability, and abstraction. In this discussion, we’ll explore the significance of polymorphism in Dart, understand how it works, and see practical examples of its use.

Understanding Polymorphism

Polymorphism is based on the idea of a shared interface or behavior. It allows different objects to respond to the same method or function call in a way that is appropriate for their respective classes. This flexibility makes code more adaptable and extensible.

Polymorphism Through Inheritance

In Dart, one common way to achieve polymorphism is through inheritance. When different classes inherit from a common superclass, they can override methods to provide their own implementations. The superclass defines a shared interface that subclasses must adhere to.

Here’s a simple example of polymorphism through inheritance:


class Animal {
    void makeSound() {
        print('Some generic sound');
    }
}

class Dog extends Animal {
    @override
    void makeSound() {
        print('Bark');
    }
}

class Cat extends Animal {
    @override
    void makeSound() {
        print('Meow');
    }

Polymorphic Behavior

Polymorphism allows you to treat objects of different classes as if they are objects of a common superclass. This shared interface enables you to call a method on objects without needing to know their specific types. The behavior exhibited by the objects will depend on their actual classes.

In the example above, you can create objects of type Animal and invoke the makeSound method without knowing whether it’s a Dog or a Cat:


Animal myPet = Dog();
myPet.makeSound(); // Outputs 'Bark'

myPet = Cat();
myPet.makeSound(); // Outputs 'Meow'

Using Abstract Classes and Interfaces

Dart provides abstract classes and interfaces as tools to define shared behaviors and create polymorphic code. An abstract class cannot be instantiated but can be inherited by other classes, ensuring that they implement the required methods. Interfaces define a set of method signatures that implementing classes must adhere to.

Here’s an example of an abstract class and an interface in Dart:


abstract class Shape {
    double area();
}

class Circle extends Shape {
    double radius;

    Circle(this.radius);

    @override
    double area() {
        return 3.14 * radius * radius;
    }
}

class Square implements Shape {
    double side;

    Square(this.side);

    @override
    double area() {
        return side * side;
    }

Compile-Time and Runtime Polymorphism

Polymorphism in Dart can be achieved at both compile-time and runtime. Compile-time polymorphism, also known as static polymorphism, occurs when method calls are determined at compile time based on the reference type. Runtime polymorphism, also known as dynamic polymorphism, involves method calls being determined at runtime based on the actual object type.

The example above demonstrates runtime polymorphism because the method calls are resolved at runtime based on the actual class of the object.

Conclusion

Polymorphism is a powerful concept in Dart that enhances code flexibility and adaptability. By allowing different classes to respond to the same method calls, it promotes code reusability and abstraction. Whether achieved through inheritance, abstract classes, or interfaces, polymorphism enables you to write more versatile and extensible code in Dart.

Dart – 11 – Polymorphism