Now that we've covered both abstract classes and interfaces, you might be wondering what you should use when you are building your app. They look similar in some ways, but there are some important differences that we'll cover now, which will make it easier for you to choose which one to use.

We've already mentioned that Kotlin doesn't allow multiple inheritance. Take a look at this example:

abstract class InsureBase {
    abstract fun insure()
}

abstract class CarBase {
    abstract fun drive()
}

//compiler error, can't inherit from multiple classes
class InsurableCar: InsureBase(), CarBase() {
    override fun insure() {
    }

    override fun drive() {
    }
}

This won't compile, because we are trying to inherit from two classes.

Interfaces don't have that limitation; a class can implement as many interfaces as it wants. So, if we want to have a type that can be both driven and insured, we can have two interfaces that define that behavior and one concrete class that implements them both:

interface Insurable {
    fun insure()
}

interface Drivable {
    fun drive()
}

class InsurableSuperCar: Insurable, Drivable {
    override fun insure() {
        println("Car is now insured")
    }

    override fun drive() {
        println("Car is driving")
    }
}

Another difference between the two is that abstract classes can have state. Abstract classes can have fields and properties, and functions that modify them. Interfaces, on the other hand, can have only function or property signatures. If you want to achieve code reuse, then this makes abstract classes a better choice.

Finally, when talking about relationships between types and whether interfaces or abstract classes should be used, usually the relationship can be broken down to is-a and can-do relationships. We can explain this better if we use types from the Java standard library. For example, the library has an abstract class called AbstractList. The class provides an implementation that is used in classes that extend it, such as ArrayList and LinkedList. When talking about ArrayList, we can always say that ArrayList is also an AbstractList.

The library also has an Iterable interface. This one has the only method, iterator(), which should return an iterator object. This interface says a type can be iterated over, so we can say this is a can-do functionality.