Mastering Inheritance and Polymorphism in Flutter

2.2.2 Inheritance and Polymorphism

In the world of software development, particularly in object-oriented programming (OOP), inheritance and polymorphism are foundational concepts that enable developers to write flexible, reusable, and maintainable code. In this section, we will explore these concepts in the context of Flutter, a popular framework for building cross-platform mobile applications. By understanding and applying inheritance and polymorphism, you can create robust Flutter applications that are both efficient and scalable.

Understanding Inheritance

Inheritance is a mechanism that allows a class to inherit properties and methods from another class. This enables code reuse and establishes a hierarchical relationship between classes. Inheritance is a cornerstone of OOP and is widely used in Flutter to create complex UI components and logic.

Base and Derived Classes

In the context of inheritance, the class that provides the properties and methods is known as the base class (or parent class), while the class that inherits from it is called the derived class (or child class). The derived class can access the properties and methods of the base class, allowing it to extend or modify the functionality.

Consider the following example:

class Animal {
  void eat() {
    print('The animal is eating');
  }
}

class Dog extends Animal {
  void bark() {
    print('The dog is barking');
  }
}

In this example, Animal is the base class, and Dog is the derived class. The Dog class inherits the eat() method from the Animal class, allowing it to use this method without redefining it.

Extending Classes

To extend a class in Dart, you use the extends keyword. This keyword establishes an inheritance relationship between the derived class and the base class. Let’s explore this further with a practical example:

class Animal {
  void eat() {
    print('The animal is eating');
  }
}

class Dog extends Animal {
  void bark() {
    print('The dog is barking');
  }
}

void main() {
  Dog myDog = Dog();
  myDog.eat();  // Inherited method
  myDog.bark(); // Method defined in Dog
}

In this code snippet, the Dog class extends the Animal class. As a result, an instance of Dog can call both the eat() method (inherited from Animal) and the bark() method (defined in Dog).

Method Overriding

Method overriding is a feature that allows a derived class to provide a specific implementation of a method that is already defined in its base class. This is useful when the behavior of a method needs to be customized for the derived class.

To override a method in Dart, you use the @override annotation. This annotation indicates that the method is intended to override a method in the base class.

Consider the following example:

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

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

void main() {
  Cat myCat = Cat();
  myCat.makeSound(); // Calls the overridden method in Cat
}

In this example, the Cat class overrides the makeSound() method from the Animal class. When makeSound() is called on an instance of Cat, the overridden method is executed, producing the output “Meow”.

Exploring Polymorphism

Polymorphism is another key concept in OOP that allows objects of different classes to be treated as objects of a common base class. This is achieved through inheritance and enables dynamic method dispatch, where the method to be invoked is determined at runtime.

Parent Class Reference to Child Class Object

In Dart, you can assign a reference of a base class to an object of a derived class. This is known as upcasting and is a fundamental aspect of polymorphism.

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

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

void main() {
  Animal myAnimal = Dog();
  myAnimal.makeSound(); // Calls the overridden method in Dog class
}

In this example, myAnimal is a reference of type Animal, but it points to an instance of Dog. When makeSound() is called on myAnimal, the overridden method in the Dog class is executed, demonstrating polymorphism.

Dynamic Method Dispatch

Dynamic method dispatch is the process by which a call to an overridden method is resolved at runtime rather than compile-time. This allows the correct method implementation to be executed based on the actual object type, not the reference type.

Abstract Classes

Abstract classes are classes that cannot be instantiated directly. They are used to define a common interface for derived classes and can contain both abstract methods (methods without implementation) and concrete methods (methods with implementation).

To declare an abstract class in Dart, you use the abstract keyword. Abstract classes are typically used when you want to provide a common base for a group of related classes.

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

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

void main() {
  Circle myCircle = Circle();
  myCircle.draw();
}

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

Interfaces in Dart

In Dart, every class implicitly defines an interface. An interface is a contract that specifies the methods a class must implement. While Dart does not have a separate keyword for interfaces, you can achieve similar functionality by using classes and the implements keyword.

Implementing Multiple Interfaces

Dart allows a class to implement multiple interfaces, enabling you to create flexible and modular code. Here’s an example:

class Printable {
  void printDetails();
}

class Scannable {
  void scan();
}

class MultiFunctionPrinter implements Printable, Scannable {
  @override
  void printDetails() {
    print('Printing document');
  }

  @override
  void scan() {
    print('Scanning document');
  }
}

void main() {
  MultiFunctionPrinter mfp = MultiFunctionPrinter();
  mfp.printDetails();
  mfp.scan();
}

In this example, MultiFunctionPrinter implements both Printable and Scannable interfaces, providing implementations for their methods.

Practice Exercises

To solidify your understanding of inheritance and polymorphism, try the following exercises:

1. Create a Class Hierarchy:

   • Design a class hierarchy for vehicles. Start with a base class Vehicle and create derived classes Car and ElectricCar.
   • Implement methods in each class that demonstrate inheritance and method overriding.

2. Utilize Polymorphism:

   • Write a program that uses a base class reference to call methods on derived class objects.
   • Experiment with dynamic method dispatch by creating a list of Vehicle objects and iterating over them to call their methods.

Best Practices and Common Pitfalls

• Use Inheritance Judiciously: While inheritance is a powerful tool, it should be used judiciously. Overusing inheritance can lead to complex and tightly coupled code. Consider using composition as an alternative when appropriate.
• Override Methods Carefully: When overriding methods, ensure that the new implementation maintains the contract established by the base class. Use the @override annotation to make your intentions clear.
• Understand Abstract Classes and Interfaces: Use abstract classes and interfaces to define common behavior and ensure consistency across related classes. This promotes code reuse and maintainability.

Conclusion

Inheritance and polymorphism are essential concepts in Flutter development, enabling you to create flexible and reusable code. By mastering these concepts, you can design robust applications that are easy to extend and maintain. Practice the exercises provided, explore the examples, and experiment with your own class hierarchies to deepen your understanding.

Quiz Time!