Abstract Classes and Interfaces in Dart

When working with Dart, understanding the concepts of abstract classes and interfaces is paramount. These concepts allow for more robust and flexible code, especially in larger applications where you need to define methods and properties while keeping your code organized and maintainable.

What is an Abstract Class?

An abstract class in Dart is a class that cannot be instantiated directly. Instead, it serves as a blueprint for other classes. You can define abstract methods—methods without an implementation—that must be overridden by subclasses. This is particularly useful for defining a common interface for multiple classes while enforcing a contract for the subclasses to follow.

Defining an Abstract Class

To declare an abstract class in Dart, you use the abstract keyword. Let’s look at a simple example to illustrate this:

abstract class Animal {
  void makeSound(); // Abstract method
}

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

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

In this example, Animal is an abstract class with one abstract method, makeSound(). The classes Dog and Cat both extend Animal and provide their own implementation for makeSound(). This way, you can create a list of animals and call makeSound() on them, knowing that each animal will provide its unique sound:

void main() {
  List<Animal> animals = [Dog(), Cat()];
  
  for (var animal in animals) {
    animal.makeSound();
  }
}

Purpose of Abstract Classes

Abstract classes are crucial when you need a base class that defines common behavior for subclasses. They allow for higher levels of abstraction and enable code reuse. For instance, if you have multiple types of vehicles (cars, bikes, trucks), you can create an abstract class Vehicle with common properties and methods such as start(), stop(), and fuelType().

What is an Interface?

In Dart, every class acts as an interface, so when you define a class, you're inherently creating an interface that can be implemented by other classes. However, Dart has specific keywords to define an interface, mainly by using the implements keyword.

Implementing Interfaces

When a class implements an interface, it must provide concrete implementations of all the methods defined in that interface.

Let’s see an example with an interface:

abstract class Drawable {
  void draw();
}

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

class Square implements Drawable {
  @override
  void draw() {
    print('Drawing a square');
  }
}

Here, Drawable serves as an interface. Both Circle and Square classes implement the Drawable interface, so they both must provide an implementation for the draw() method. You can then create instances of these shapes and call the draw() method:

void main() {
  List<Drawable> shapes = [Circle(), Square()];
  
  for (var shape in shapes) {
    shape.draw();
  }
}

Purpose of Interfaces

Interfaces are powerful when you want to define a contract for methods without dictating how they should be implemented. This allows for flexibility in how different classes can provide their implementations while adhering to a shared contract.

Key Differences Between Abstract Classes and Interfaces

While abstract classes and interfaces in Dart can often be used interchangeably, there are some key differences you should be aware of:

Instantiation:
- An abstract class cannot be instantiated directly.
- An interface (class) cannot be instantiated either, but it is a way to define methods used by other classes.
Method Implementation:
- Abstract classes can have both abstract methods and methods with implementations.
- Interfaces cannot have implementations in Dart and only declare method signatures.
Inheritance:
- A class can extend only one abstract class.
- A class can implement multiple interfaces.
Purpose:
- Use abstract classes when you want to share code among closely related classes.
- Use interfaces to define a contract that unrelated classes can implement.

When to Use Abstract Classes vs. Interfaces

Choosing between an abstract class and an interface depends on your scenario:

Abstract Classes: Selecting an abstract class is more suitable when you intend to share code or common functionality among the classes. For example, consider a scenario with a class hierarchy where you share some properties or methods, like Vehicle with subclasses Car and Truck.
Interfaces: An interface should be your choice when you want to facilitate a contract that several diverse classes can adhere to, without creating a hierarchy. For instance, classes like CanFly, CanSwim, or CanDrive can serve as interfaces that multiple classes can implement, regardless of their place in the class hierarchy.

Example of Combined Use

In many applications, you might need to use both abstract classes and interfaces. For instance:

abstract class Shape {
  double area();
}

abstract class Drawable {
  void draw();
}

class Circle extends Shape implements Drawable {
  double radius;

  Circle(this.radius);

  @override
  double area() => 3.14 * radius * radius;

  @override
  void draw() {
    print('Drawing a circle');
  }
}

class Rectangle extends Shape implements Drawable {
  double width, height;

  Rectangle(this.width, this.height);

  @override
  double area() => width * height;

  @override
  void draw() {
    print('Drawing a rectangle');
  }
}

In this example, Shape is an abstract class that contains an area() method. The Drawable interface defines a draw() method. Both Circle and Rectangle provide implementations for these methods. This design encapsulates functionality while allowing for polymorphism and extensibility.

Conclusion

Abstract classes and interfaces are essential constructs in Dart that help create well-structured and maintainable code. By understanding their differences and when to use each, you can leverage their strengths to design systems that are both flexible and efficient. As you continue developing in Dart, keep these concepts in mind to enhance your coding practices and improve the architecture of your applications. Happy coding!

Programming - Dart