Mastering Inheritance and Polymorphism in Dart: A Comprehensive Guide

2.4.2 Inheritance and Polymorphism

In the realm of object-oriented programming (OOP), inheritance and polymorphism are two fundamental concepts that enable developers to create flexible and reusable code. Dart, the language behind Flutter, fully supports these OOP principles, allowing you to build robust and scalable applications. This section will delve into these concepts, providing you with a solid understanding and practical skills to apply them in your projects.

Understanding Inheritance

Inheritance is a mechanism that allows a new class, known as a subclass or derived class, to inherit properties and methods from an existing class, referred to as a superclass or base class. This promotes code reuse and establishes a natural hierarchy between classes.

Base Class (Super Class)

A base class is a general class that provides common functionality to its subclasses. Let’s consider a simple example with a Vehicle class:

class Vehicle {
  void start() {
    print('Vehicle started');
  }
}

In this example, Vehicle is a base class with a method start(), which can be used by any class that extends Vehicle.

Derived Class (Sub Class)

A derived class extends the functionality of a base class. Here’s how you can create a Car class that inherits from Vehicle:

class Car extends Vehicle {
  void drive() {
    print('Car is driving');
  }
}

The Car class inherits the start() method from Vehicle and adds its own method drive().

Usage Example

Let’s see how you can use these classes:

void main() {
  var myCar = Car();
  myCar.start(); // Output: Vehicle started
  myCar.drive(); // Output: Car is driving
}

In this example, myCar is an instance of Car, which can use both the start() method from Vehicle and the drive() method from Car.

Method Overriding

Method overriding allows a subclass to provide a specific implementation of a method that is already defined in its superclass. This is useful when you want to change or extend the behavior of a method.

class Car extends Vehicle {
  @override
  void start() {
    print('Car ignition started');
  }
}

Here, the Car class overrides the start() method of Vehicle. When you call start() on an instance of Car, it will execute the overridden method.

Polymorphism

Polymorphism is the ability to treat objects of different classes through the same interface. This means you can write code that works on the superclass type, but it can operate on any subclass type.

void main() {
  Vehicle vehicle = Car();
  vehicle.start(); // Output: Car ignition started
}

In this example, vehicle is a reference of type Vehicle, but it points to an instance of Car. When start() is called, it executes the overridden method in Car.

Visual Diagrams

To better understand the relationships between classes, let’s visualize the inheritance hierarchy using Mermaid.js:

    classDiagram
	    class Vehicle {
	        +void start()
	    }
	    class Car {
	        +void drive()
	        +void start()
	    }
	    Vehicle <|-- Car

This diagram shows that Car inherits from Vehicle and overrides the start() method.

Abstract Classes and Methods

Abstract classes are classes that cannot be instantiated directly. They are designed to be subclassed, providing a template for other classes. Abstract methods are methods that are declared without an implementation.

abstract class Shape {
  void draw(); // Abstract method
}

class Circle extends Shape {
  @override
  void draw() {
    print('Drawing a circle');
  }
}

In this example, Shape is an abstract class with an abstract method draw(). The Circle class extends Shape and provides an implementation for draw().

Interactive Exercise

To reinforce your understanding, try creating an inheritance hierarchy with the following classes:

• Animal (base class)
• Mammal (subclass of Animal)
• Bird (subclass of Animal)

Implement methods that demonstrate overriding, such as speak() for Animal, walk() for Mammal, and fly() for Bird.

Best Practices and Common Pitfalls

• Use Inheritance Judiciously: While inheritance promotes code reuse, overusing it can lead to complex and tightly coupled code. Consider composition as an alternative.
• Override Methods Carefully: Ensure that overridden methods maintain the expected behavior of the superclass.
• Leverage Polymorphism: Use polymorphism to write flexible and maintainable code that can work with different subclasses.

Additional Resources

• Dart Language Tour
• Effective Dart: Style
• Object-Oriented Programming in Dart

By mastering inheritance and polymorphism, you’ll be able to create more organized and scalable applications. These concepts are foundational to object-oriented programming and are widely used in software development.

Quiz Time!