What is an Interface in Dart?

An interface in Dart is a contract that defines a set of methods and properties that a class must implement. Unlike some other programming languages, Dart does not have a specific keyword for defining interfaces. Instead, any class can act as an interface, and other classes can implement that interface using the implements keyword. This allows for a flexible and powerful way to define shared behavior across different classes.

1. Defining an Interface

To define an interface in Dart, you simply create a class with the desired methods and properties. The class can contain both abstract methods (methods without an implementation) and concrete methods (methods with an implementation). However, when a class is used as an interface, it is common to define only abstract methods.

Example of an Interface

class Animal {
    void speak(); // Abstract method
    void eat();   // Abstract method
}

In this example, we define a class Animal that serves as an interface. It contains two abstract methods: speak and eat. Any class that implements this interface must provide concrete implementations for these methods.

2. Implementing an Interface

To implement an interface, a class uses the implements keyword followed by the interface name. The implementing class must provide concrete implementations for all the methods defined in the interface.

Example of Implementing an Interface

class Dog implements Animal {
    @override
    void speak() {
        print('Dog barks.');
    }

    @override
    void eat() {
        print('Dog eats.');
    }
}

class Cat implements Animal {
    @override
    void speak() {
        print('Cat meows.');
    }

    @override
    void eat() {
        print('Cat eats.');
    }
}

void main() {
    Dog myDog = Dog();
    myDog.speak(); // Output: Dog barks.
    myDog.eat();   // Output: Dog eats.

    Cat myCat = Cat();
    myCat.speak(); // Output: Cat meows.
    myCat.eat();   // Output: Cat eats.
}

In this example, both the Dog and Cat classes implement the Animal interface. Each class provides its own implementation of the speak and eat methods. When we create instances of Dog and Cat, we can call their respective methods.

3. Benefits of Using Interfaces

• Code Reusability: Interfaces allow you to define common behavior that can be reused across multiple classes, promoting consistency.
• Decoupling Code: By using interfaces, you can decouple the implementation from the interface, making your code more flexible and easier to maintain.
• Polymorphism: Interfaces enable polymorphism, allowing you to treat different classes that implement the same interface as instances of that interface.

4. Conclusion

In Dart, interfaces are a powerful feature that allows you to define a contract for classes to follow. By using the implements keyword, you can create flexible and reusable code structures that promote consistency and maintainability. Understanding how to define and implement interfaces effectively is essential for building robust Dart applications.