Thread: What good are interfaces?

I wrote these articles quite a while ago. I'm not sure if they are even complete, and glancing through them I kind of want to re-write them.

General CS Concepts: Abstraction
General CS Concepts: Polymorphism
General CS Concepts: Interfaces

General broad over-view:

Interfaces are only useful if we want to write handler code in a generic manner. It has nothing to do with lambdas (indeed, interfaces have been in Java since day 1, lambdas are a fairly new feature introduced in the latest version of Java). It allows us to declare that some class "has" some method implemented.

Suppose we have the following classes TaskA and TaskB:

public class TaskA implements Runnable
{
    public void run()
    {
        System.out.println("Hello from TaskA!");
    }
}

public class TaskB implements Runnable
{
    public void run()
    {
        System.out.println("Aloha from Task B!");
    }
}

They both implements the Runnable interface, which means the must contain the method public void run().

We can use these classes directly and never have to deal with interfaces, polymorphism, or abstraction:

public static void runner(TaskA var)
{
    var.run();
}
 
public static void runner(TaskB var)
{
    var.run();
}

But I just wrote the same code twice! It would get much worse if I decide later that I wanted to add classes TaskC, TaskD, ... etc. Why am I re-writing the exact same code multiple times just because I want to call the run method?

It would be much simpler to have some type which explicitly states that the held variable has a run method. This is where Runnable comes in: that's exactly what it does.

public static void runner(Runnable var)
{
    var.run();
}

Polymorphism is only one such solution to this problem, and it works quite well. In Java this is the preferred solution because it works well, the syntax is clean, and conceptually is fairly easy to grasp.

An alternative solution with Java is using reflection, however I would strongly caution against going down that path because reflection is a run-time tool, not a compile-time tool. The syntax isn't clean, and reflection will perform worse than polymorphism because it has extra work to do at runtime.

In C++ there are templates (basically a suped-up much more powerful version of Java's generics) which could allow us to write similarly generic version of runner without ever having to touch interfaces or polymorphism. That being said, there are problems which templates or generics can't solve that Polymorphism can, and vise-versa.