What are interfaces?
An interface is a blueprint for a set of methods that a class can implement. It defines a set of methods that must be implemented by any class that implements the interface. An interface does not have any implementation code, but it only defines the signatures of the methods that a class must implement. In other words, an interface is a contract that specifies what methods a class should have, but not how those methods should be implemented.
In Dart, an interface is defined using the abstract keyword followed by the keyword class. The methods inside the interface are also declared as abstract and do not have a body. Here is an example of an interface:
abstract class Vehicle {
void start();
void stop();
}
This interface declares two methods, start() and stop(), which must be implemented by any class that implements the Vehicle interface. Here is an example of a class that implements the Vehicle interface:
class Car implements Vehicle {
void start() {
// Implementation of start() method for Car class
}
void stop() {
// Implementation of stop() method for Car class
}
}
The Car class implements the Vehicle interface by providing its own implementation for the start() and stop() methods. Note that the implementation of these methods can be different for different classes that implement the same interface.
What are abstract classes?
An abstract class is a class that cannot be instantiated directly, but it can be used as a base class for other classes. It can contain both abstract and non-abstract methods. An abstract method is a method that does not have a body and is declared using the abstract keyword. Any class that extends an abstract class must implement all the abstract methods of the abstract class. Abstract classes are useful when you want to define a base class that provides a common interface or behavior for a group of related classes.
In Dart, an abstract class is defined using the abstract keyword followed by the keyword class. Here is an example of an abstract class:
abstract class Animal {
void eat();
void sleep() {
print("Animal is sleeping");
}
}
This abstract class declares an abstract method eat() and a non-abstract method sleep(). Any class that extends the Animal class must implement the eat() method.
Here is an example of a class that extends the Animal class:
class Cat extends Animal {
void eat() {
// Implementation of eat() method for Cat class
}
void meow() {
print("Meow!");
}
}
The Cat class extends the Animal class and provides its own implementation for the eat() method. It also has its own non-abstract method meow(). Note that the Cat class must implement the eat() method because it extends the Animal class, which is an abstract class.
Example
Let's look at an example that combines both interfaces and abstract classes. Suppose we have a set of vehicles that can start and stop, but each type of vehicle has its own way of starting and stopping. We can define an interface called Vehicle that specifies the methods start() and stop(). We can then define an abstract class called AbstractVehicle that implements the Vehicle interface and provides some common functionality for all vehicles. Finally, we can define concrete classes that extend the AbstractVehicle class and provide their own implementation for the start() and stop() methods.
Here is the code for the Vehicle interface:
abstract class Vehicle {
void start();
void stop();
}
Here is the code for the AbstractVehicle class:
abstract class AbstractVehicle implements Vehicle {
void start() {
// Common code for starting a vehicle
print("Vehicle is starting...");
}
void stop() {
// Common code for stopping a vehicle
print("Vehicle is stopping...");
}
}
Note that the AbstractVehicle class implements the Vehicle interface and provides a common implementation for the start() and stop() methods.
Now, let's define a concrete class called Car that extends the AbstractVehicle class:
class Car extends AbstractVehicle {
void start() {
super.start(); // Call the start method from the parent class
print("Car is starting...");
}
void stop() {
super.stop(); // Call the stop method from the parent class
print("Car is stopping...");
}
}
The Car class extends the AbstractVehicle class and provides its own implementation for the start() and stop() methods. Note that it calls the start() and stop() methods from the parent class using the super keyword before providing its own implementation.
Here is an example usage of the Car class:
void main() {
Car car = Car();
car.start();
car.stop();
}
This code will output:
Vehicle is starting...
Car is starting...
Vehicle is stopping...
Car is stopping...
As you can see, the start() and stop() methods from the AbstractVehicle class are called before the start() and stop() methods from the Car class. This allows us to provide a common implementation for all vehicles while still allowing each type of vehicle to have its own unique implementation.
In conclusion, interfaces and abstract classes are powerful features in Dart that allow developers to create more flexible and modular code. Interfaces allow us to define a contract that specifies what methods a class should have, while abstract classes allow us to provide a common implementation for a group of related classes. By using these features, we can create more reusable and maintainable code.
0 Comments