Thread: General question about Interfaces

For a single class interfaces aren't terribly useful, and you're right that it looks just like unnecessary overhead/boilerplate code.

However, consider a few different classes:

Car, Truck, Boat, Lawnmower, etc.

These can all be driven, so you could create an interface Drivable with a method drive(x,y).

You can still use each class separately and "ignore" the fact that each class is Drivable. A car could still have a drive method even if it didn't implement the Drivable interface, and same with Truck, Boat, etc. However, what implementing Drivable does is it forces these classes to have this drive(x,y) method, so the user of these classes can treat them all as Drivable objects.

This means we can do something like this:

ArrayList<Drivable> myVehicles = new ArrayList<Drivable>();
// let's add a few Drivable items
myVehicles.add(new Car());
myVehicles.add(new Truck());
myVehicles.add(new Lawnmower());
 
// for each vehicle, drive them home
for(Drivable d : myVehicles)
{
    d.drive(0,0);
}

Without the use of interfaces/inheritance/abstraction, I would be forced to maintain separate lists of vehicles for each type of vehicle.

ArrayList<Car> myCars = new ArrayList<Car>();
ArrayList<Truck> myTrucks = new ArrayList<Truck>();
// ...

This is cumbersome and error-prone when all I want is have a single list of objects which are Drivable.

Oops, sorry for adding in extra syntax and features.

ArrayList<Drivable> myVehicles = new ArrayList<Drivable>();

Drivable is an interface. This declares an ArrayList which can hold anything which is Drivable. Car, Truck, and Lawnmower all implement the Drivable interface so myVehicles can hold them.

for(Drivable d : myVehicles)
{
}

This is the for-each declaration. It basically loops through all the items in myVehicles.

d.drive(0,0);

This calls the drive method for the Drivable object d. Here's an example implementation of Drivable:

public Interface Drivable
{
    public void drive(int x, int y);
}

It's not terrible important what this does, it's just a demonstration class.

Here's a simpler version which does a similar thing:

Drivable[] myVehicles = new Drivable[3];
myVehicles[0] = new Car();
myVehicles[1] = new Truck();
myVehicles[2] = new Lawnmower();
 
// for each vehicle, drive them home
for(int i = 0; i < myVehicles.length; ++i)
{
    myVehicles[i].drive(0, 0);
}