Question

Trying to understand a question I got wrong on a test:

---

How does inheritance differ from implementing interfaces?

1. With inheritance, a class gains behavior from its superclass.
2. With interfaces, a class gains behavior from the interface it implements. (this is the one I chose)
3. With inheritance, a class must implement the methods defined by its superclass.
4. With interfaces, a class gains both instance variables and behaviors from the interface it implements.

The way I was thinking is that interfaces define behavior, while superclasses define characteristics… or are they the same? Or am I completely backwards in my understanding?

---

Edit: I guess I should specify that I do know the difference between interfaces and inheritance. I’m just wondering about the two options which use the term behavior. I don’t know if the prof was nitpicking about terminology, or if he asked the question poorly.

I know that when you implement an interface, you have to implement all the methods as defined in the interface. As such, I would say that the interface defines the behavior that a class must have, but extending another superclass (although it does also define some behaviors (more can be given to the subclass), it doesn’t seem to fit as strongly as the interface defining behaviors. If the class implements an interface, you can be sure that it has certain behaviors.

Maybe the question was meant to ask whether or not the interface itself has the code for the behavior, or if it’s just the definition – which if worded that way, I would have known the answer.

Answer 1

I think some of your misunderstanding might stem purely from semantics. Perhaps a more straightforward way of describing an interface is that it defines an API but does not provide an implementation of that API. One caveat is that I will use Java for my example but in a language like C++, implementing an interface is inheritance of a special sort – namely inheriting from a class consisting of pure virtual functions.

In Java, for instance, you might have an EventListener interface defined as:

public interface IEventListener {
    public void handleEvent(Event event);
}

The interface does not, to use the question’s verbiage, say anything about how a class that implements the IEventListener interface will behave when it receives an event it only ensures that any class implementing this interface will have the characteristic of being able to receive an event of type Event.

Inheritance, on the other hand, allows super classes to also inherit behavior (implementation). For instance, consider the following Java base class:

public abstract BaseClass {
    public void baseMethod(int value) {
        System.out.println(int);
}

public class SubClass extends BaseClass {
}

Any class that inherits from BaseClass gains both the API (characteristics) of BaseClass and also the implementation (behavior). In other words not only can you invoke instanceOfSubClass.baseMethod(1), a characteristic, doing so will result in the behavior defined in the BaseClass, namely 1 being printed to the console.

So your answer (2) is incorrect because interfaces do not specify behavior (implementation) only API (characteristics). Inheritance can handle both.

I think the point of the question is to explain that inheritance is specifically useful when you want to share behavior and not just API. That said, implementation (behavior) can also be shared via composition and such a strategy is often better – see Item 16 in Bloch’s Effective Java for an excellent discussion.