The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Interfaces

Next ►
►

In Dart, interfaces are a powerful feature that allows you to define a contract that classes can implement. This is particularly useful for ensuring that different classes adhere to a specific structure, making your code more modular and easier to maintain.

Key Concepts

  1. Definition: An interface in Dart is a class that defines methods and properties without implementing them. Any class that implements an interface must provide concrete implementations for all the methods and properties defined in the interface.
  2. Usage: Interfaces are used to define a set of methods and properties that a class must implement, ensuring a consistent API across different classes.
  3. Syntax: In Dart, any class can be used as an interface. You use the implements keyword to implement an interface.

Example

Let's start with a simple example to illustrate how interfaces work in Dart.

Step 1: Define an Interface

abstract class Animal {
  void makeSound();
  void move();
}

In this example, Animal is an abstract class that serves as an interface. It defines two methods: makeSound and move.

Step 2: Implement the Interface

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

  @override
  void move() {
    print('Run');
  }
}

class Bird implements Animal {
  @override
  void makeSound() {
    print('Chirp');
  }

  @override
  void move() {
    print('Fly');
  }
}

Here, Dog and Bird are two classes that implement the Animal interface. Each class provides its own implementation of the makeSound and move methods.

Step 3: Using the Implemented Classes

void main() {
  Animal dog = Dog();
  dog.makeSound(); // Output: Bark
  dog.move();      // Output: Run

  Animal bird = Bird();
  bird.makeSound(); // Output: Chirp
  bird.move();      // Output: Fly
}

In the main function, we create instances of Dog and Bird and call their methods. This demonstrates how different classes can implement the same interface in different ways.

Practical Exercise

Exercise 1: Define and Implement an Interface

  1. Define an interface called Shape with two methods: area and perimeter.
  2. Implement the Shape interface in two classes: Circle and Rectangle.
  3. Write a main function to create instances of Circle and Rectangle, and print their area and perimeter.

Solution

abstract class Shape {
  double area();
  double perimeter();
}

class Circle implements Shape {
  double radius;

  Circle(this.radius);

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

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

class Rectangle implements Shape {
  double width;
  double height;

  Rectangle(this.width, this.height);

  @override
  double area() {
    return width * height;
  }

  @override
  double perimeter() {
    return 2 * (width + height);
  }
}

void main() {
  Shape circle = Circle(5);
  print('Circle Area: ${circle.area()}'); // Output: Circle Area: 78.5
  print('Circle Perimeter: ${circle.perimeter()}'); // Output: Circle Perimeter: 31.400000000000002

  Shape rectangle = Rectangle(4, 6);
  print('Rectangle Area: ${rectangle.area()}'); // Output: Rectangle Area: 24
  print('Rectangle Perimeter: ${rectangle.perimeter()}'); // Output: Rectangle Perimeter: 20
}

Common Mistakes and Tips

  1. Forgetting to Implement All Methods: When a class implements an interface, it must provide concrete implementations for all the methods and properties defined in the interface. If you forget to implement any method, Dart will throw an error.
  2. Using abstract Keyword: While defining an interface, you can use the abstract keyword to indicate that the class is meant to be used as an interface and should not be instantiated directly.
  3. Consistent Naming: Ensure that the method names and signatures in the implementing classes match those defined in the interface.

Conclusion

Interfaces in Dart provide a way to define a contract that classes must adhere to, ensuring consistency and modularity in your code. By using interfaces, you can create flexible and maintainable code that can be easily extended and modified. In the next section, we will explore more advanced features of Dart, such as asynchronous programming.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved